servicebuildermdl_test.go 20.7 KiB
Newer Older
package servicebuildermdl

import (
	"encoding/json"
	"errors"
	"strconv"
	"testing"
Ajit Jagtap's avatar
Ajit Jagtap committed
	"time"
Ajit Jagtap's avatar
Ajit Jagtap committed
	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/errormdl"

Ajit Jagtap's avatar
Ajit Jagtap committed
	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/cachemdl"
	"corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/loggermdl"

	dalmdl "corelab.mkcl.org/MKCLOS/coredevelopmentplatform/corepkgv2/dalmdl/dao"

	"github.com/stretchr/testify/assert"
	"github.com/tidwall/gjson"
)

Ajit Jagtap's avatar
Ajit Jagtap committed
var fastCache cachemdl.FastCacheHelper
var loaddata LoadData

func init() {
	fastCache = cachemdl.FastCacheHelper{}
	fastCache.Setup(5000, time.Minute*500, time.Minute*500)
}

//Create Type with abstract Type
type MyBLLayer struct {
	AbstractBusinessLogicHolder
}

// // attach methods to it
// func (m *MyBLLayer) FindAndVerifyMobileNumber() map[string]interface{} {
// 	loginID := "noone"
// 	//check in cache
// 	fresult, okay := fastCache.Get("#[mobileNo==\"7875383220\"].loginId")
// 	if okay {
// 		loginID = fresult.(string)
// 	} else {
// 		result1, ok := m.GetDataResultset("daodata1")
// 		if !ok {
// 			loggermdl.LogError("error in convert")
// 		}
// 		loginID = result1.Get("#[mobileNo==\"7875383220\"].loginId").String()
// 		fastCache.Set("#[mobileNo==\"7875383220\"].loginId", loginID)
// 	}

// 	//add few var in local map and fetch it
// 	result2, _ := m.GetDataResultset("daodata1")
// 	m.SetResultset("myresult2", result2)
// 	m.LocalServiceData["myint"] = 5
// 	m.GetDataResultset("myresult2")
// 	errormdl.IsTestingNegetiveCaseOnCheckBool = true
// 	errormdl.IsTestingNegetiveCaseOnCheckBool1 = true
// 	m.GetDataResultset("myresult2")

// 	errormdl.IsTestingNegetiveCaseOnCheckBool = false
// 	errormdl.IsTestingNegetiveCaseOnCheckBool1 = false
// 	cnt1, _ := m.GetDataInt("hi")
// 	if cnt1 > 1 {
// 		fmt.Println("hmm")
// 	}

// 	errormdl.IsTestingNegetiveCaseOnCheckBool = true
// 	errormdl.IsTestingNegetiveCaseOnCheckBool1 = false
// 	cnt2, _ := m.GetDataInt("hi")
// 	if cnt2 > 1 {
// 		fmt.Println("hmm")
// 	}

// 	m.SetFinalData(loginID)

// 	return map[string]interface{}{
// 		"owner": loginID,
// 	}

// }

//Now we will write DAO
func GetUsersInfo() (*gjson.Result, error) {
	return dalmdl.GetDAO().FilePath("../testingdata/users.json").IsCacheable(true).Query("*").Run()
}

// func TestService(t *testing.T) {
// 	mb := MyBLLayer{}
// 	mb.Build()

// 	loaddata := func(ab *AbstractBusinessLogicHolder) error {
// 		data, err := GetUsersInfo()
// 		if err != nil {
// 			loggermdl.LogError(err)
// 			return err
// 		}
// 		mb.LocalServiceData["daodata1"] = data
// 		return nil
// 	}

// 	// GetSB("mysrv", &mb.AbstractBusinessLogicHolder).
// 	// 	AddStep("Check Mobile", "owner in ('SystemIntegrator')", loaddata, mb.FindAndVerifyMobileNumber, mb.EchoBL)

// 	// loaddata := func(ab *AbstractBusinessLogicHolder) {
// 	// 	mb.LocalServiceData["daodata1"] = GetUsersInfo()
// 	// }

// 	// finalStep := func(ab *AbstractBusinessLogicHolder) *interface{} {
// 	// 	s :=
// 	// 	return &s
// 	// }

// 	sb, err := GetSB("mysrv", &mb.AbstractBusinessLogicHolder).
// 		AddStep("Check Mobile", "owner = 'SystemIntegrator'", loaddata, mb.FindAndVerifyMobileNumber, mb.EchoBL).
// 		AddStep("Test STEP 2", "owner = 'SystemIntegrator'", nil, mb.FindAndVerifyMobileNumber, mb.EchoBL).
// 		Run().FinalOutput(nil)
// 	if err != nil {
// 		loggermdl.LogError(err)
// 	} else {
// 		assert.Equal(t, "SystemIntegrator", *sb, "this should be same")

// 	}

// }

/*****************************************************/

func (m *MyBLLayer) BL1() (map[string]interface{}, error) {
	condition, ok1 := m.GetDataBool("condition")
	rs, ok := m.GetDataResultset("daodata1")
	if ok && ok1 {
		tmp := rs.Get("#[isEnabled==" + strconv.FormatBool(condition) + "]#").Get("#.loginId")
		loggermdl.LogInfo(tmp)
		m.SetResultset("BL1Data", &tmp)
Ajit Jagtap's avatar
Ajit Jagtap committed
	}
	return map[string]interface{}{
		"$1": true,
	}, nil
}
func (m *MyBLLayer) BL2() (map[string]interface{}, error) {
	loginIDs, ok1 := m.GetDataResultset("BL1Data")
	rs, ok := m.GetDataResultset("daodata1")
	if ok && ok1 {
		var tmp []interface{}
		loginIDs.ForEach(func(key, value gjson.Result) bool {
			tmp = append(tmp, rs.Get("#[loginId=="+value.String()+"]#").Value())
			return true
		})
		m.SetFinalData(tmp)
	}
	return map[string]interface{}{
		"$1": true,
	}, nil
}

func (m *MyBLLayer) BL3() (map[string]interface{}, error) {
Ajit Jagtap's avatar
Ajit Jagtap committed
	errormdl.IsTestingNegetiveCaseOnCheckBool = true
	condition, ok1 := m.GetDataBool("condition")
	errormdl.IsTestingNegetiveCaseOnCheckBool = false
	rs, ok := m.GetDataResultset("daodata1")
	if ok && ok1 {
		tmp := rs.Get("#[isEnabled==" + strconv.FormatBool(condition) + "]#").Get("#.loginId")
		loggermdl.LogInfo(tmp)
		m.SetResultset("BL1Data", &tmp)
	}
	return map[string]interface{}{
		"$1": true,
	}, nil
}

func (m *MyBLLayer) BL4() (map[string]interface{}, error) {
Ajit Jagtap's avatar
Ajit Jagtap committed
	errormdl.IsTestingNegetiveCaseOnCheckBool1 = true
	condition, ok1 := m.GetDataBool("condition")
	rs, ok := m.GetDataResultset("daodata1")
	errormdl.IsTestingNegetiveCaseOnCheckBool1 = false
	if ok && ok1 {
		tmp := rs.Get("#[isEnabled==" + strconv.FormatBool(condition) + "]#").Get("#.loginId")
		loggermdl.LogInfo(tmp)
		m.SetResultset("BL1Data", &tmp)
	}
	return map[string]interface{}{
		"$1": true,
	}, nil
}
Ajit Jagtap's avatar
Ajit Jagtap committed

func (m *MyBLLayer) BL5() (map[string]interface{}, error) {
	errormdl.IsTestingNegetiveCaseOnCheckBool1 = true
	condition, ok1 := m.GetDataBool("condition")
	rs, ok := m.GetDataResultset("daodata1")
Ajit Jagtap's avatar
Ajit Jagtap committed
	errormdl.IsTestingNegetiveCaseOnCheckBool1 = false
	if ok && ok1 {
		tmp := rs.Get("#[isEnabled==" + strconv.FormatBool(condition) + "]#").Get("#.loginId")
		loggermdl.LogInfo(tmp)
		m.SetResultset("BL1Data", &tmp)
	} else {
		return nil, errors.New("NO_DATA_FOUND")
	}
	return map[string]interface{}{
		"$1": true,
	}, nil
}

func (m *MyBLLayer) BL6() (map[string]interface{}, error) {
	condition, ok1 := m.GetDataBool("condition")
	rs, ok := m.GetDataResultset("daodata1")
	if ok && ok1 {
		tmp := rs.Get("#[isEnabled==" + strconv.FormatBool(condition) + "]#").Get("#").Int()
		loggermdl.LogInfo(tmp)
		m.SetCustomData("BL1Data", tmp)
		loginIDs, ok1 := m.GetDataInt("BL1Data")
		loggermdl.LogInfo(loginIDs, ok1)
		if ok1 {
			m.SetFinalData(loginIDs)
		}
	}
	return map[string]interface{}{
		"$1": true,
	}, nil
}

func (m *MyBLLayer) BL7() (map[string]interface{}, error) {
	loginIDs, ok1 := m.GetDataInt("BL1Data")
	loggermdl.LogInfo(loginIDs, ok1)
	if ok1 {
		m.SetFinalData(loginIDs)
	}
	return map[string]interface{}{
		"$1": true,
	}, nil
}

func (m *MyBLLayer) BL8() (map[string]interface{}, error) {
	rs, ok := m.GetDataResultset("daodata1")
	if ok {
		tmp := rs.Get("#[isEnabled==true]#").Get("#").Value()
		m.SetCustomData("BL1Data", tmp)
		loginIDs, ok1 := m.GetDataInt("BL1Data")
		if ok1 {
			m.SetFinalData(loginIDs)
		}
	}
	return map[string]interface{}{
		"$1": true,
	}, nil
}

func (m *MyBLLayer) BL9() (map[string]interface{}, error) {
	loginIDs, ok1 := m.GetDataInterface("BL1Data1")
	loggermdl.LogInfo(loginIDs, ok1)
	if ok1 {
		m.SetFinalData(loginIDs)
	}
	return map[string]interface{}{
		"$1": true,
	}, nil
}

func (m *MyBLLayer) BL10() (map[string]interface{}, error) {
	loginId, ok1 := m.GetDataString("loginId")
	rs, ok := m.GetDataResultset("daodata1")
	if ok && ok1 {
		tmp := rs.Get("#[loginId==" + loginId + "]#").Value()
		loggermdl.LogInfo(tmp)
		m.SetFinalData(tmp)

	}
	return map[string]interface{}{
		"$1": true,
	}, nil
}

func Test1Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		// mb.LocalServiceData["daodata1"] = data
		mb.SetResultset("daodata1", data)
		return nil
	}
	mb.SetCustomData("condition", false)

	ab, Err := GetSB("Test1Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL1, mb.EchoBL).
		AddStep("Step2", "$1 == true", nil, mb.BL2, mb.EchoBL).
		Run(nil)
	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
	}
	assert.NoError(t, Err, "No Error Should be return")
}

func Test2Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		// mb.LocalServiceData["daodata1"] = data
		mb.SetResultset("daodata1", data)
		return nil
	}

	mb.SetCustomData("condition", false)
	ab, Err := GetSB("Test1Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "abc == true", loaddata, mb.BL1, mb.EchoBL).
		AddStep("Step2", "abc == true", nil, mb.BL2, mb.EchoBL).
		Run(nil)

	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
	}
	assert.Error(t, Err, "No Error Should be return")

}

func Test3Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		// mb.LocalServiceData["daodata1"] = data
		mb.SetResultset("daodata1", data)
		return nil
	}

	mb.SetCustomData("condition", false)
	ab, Err := GetSB("Test1Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL1, mb.EchoBL).
		AddStep("Step2", "$2 == true", nil, mb.BL2, mb.EchoBL).
		Run(nil)

	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
	}
	assert.Error(t, Err, "No Error Should be return")

}

func Test4Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		// mb.LocalServiceData["daodata1"] = data
		mb.SetResultset("daodata1", data)
		return nil
	}

	mb.SetCustomData("condition", false)
	ab, Err := GetSB("Test1Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL1, mb.EchoBL).
		AddStep("Step2", "$1 == false", nil, mb.BL2, mb.EchoBL).
		Run(nil)

	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
	}
	assert.NoError(t, Err, "No Error Should be return")

}

func Test5Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		// mb.LocalServiceData["daodata1"] = data
		mb.SetResultset("daodata1", data)
		return nil
	}

	mb.SetCustomData("condition", false)
	ab, Err := GetSB("Test1Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL3, mb.EchoBL).
		AddStep("Step2", "$1 == false", nil, mb.BL2, mb.EchoBL).
		Run(nil)

	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
Ajit Jagtap's avatar
Ajit Jagtap committed
	}
	assert.NoError(t, Err, "No Error Should be return")
Ajit Jagtap's avatar
Ajit Jagtap committed

}

func Test6Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		// mb.LocalServiceData["daodata1"] = data
		mb.SetResultset("daodata1", data)
		return nil
	}

	mb.SetCustomData("condition", false)
	ab, Err := GetSB("Test1Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL4, mb.EchoBL).
		AddStep("Step2", "$1 == false", nil, mb.BL2, mb.EchoBL).
		Run(nil)

	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
	}
	assert.NoError(t, Err, "No Error Should be return")

}

func Test7Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		// mb.LocalServiceData["daodata1"] = data
		mb.SetResultset("daodata1", data)
		return nil
	}

	mb.SetCustomData("condition", false)
	ab, Err := GetSB("Test1Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL5, mb.EchoBL).
		AddStep("Step2", "$1 == false", nil, mb.BL2, mb.EchoBL).
		Run(nil)

	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
	}
	assert.Error(t, Err, "No Error Should be return")

}

func Test8Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		return errors.New("CUSTOM_DAO_ERROR")
	}

	mb.SetCustomData("condition", false)
	ab, Err := GetSB("Test1Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL1, mb.EchoBL).
		AddStep("Step2", "$1 == false", nil, mb.BL2, mb.EchoBL).
		Run(nil)

	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
	}
	assert.Error(t, Err, "No Error Should be return")

}

func Test9Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		// mb.LocalServiceData["daodata1"] = data
		mb.SetResultset("daodata1", data)
		return nil
	}

	mb.SetCustomData("condition", false)
	ab, Err := GetSB("Test1Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == false", loaddata, mb.BL1, mb.ErrorFunction).
		AddStep("Step2", "$1 == true", nil, mb.BL2, mb.ErrorFunction).
		Run(nil)

	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
	}
	assert.Error(t, Err, "No Error Should be return")

}

func (m *MyBLLayer) ErrorFunction() (map[string]interface{}, error) {
	return nil, errors.New("Error_Func")
}

func Test10Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		mb.SetResultset("daodata1", data)
		return nil
	}

	resultFunc := func(ab *AbstractBusinessLogicHolder) (*interface{}, error) {
		return ab.GetFinalData(), nil
	}
	mb.SetCustomData("condition", false)
	ab, Err := GetSB("Test10Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL1, mb.ErrorFunction).
		AddStep("Step2", "$1 == true", nil, mb.BL2, mb.ErrorFunction).
		Run(resultFunc)

	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
	}
	assert.NoError(t, Err, "No Error Should be return")

}

func Test11Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		mb.SetResultset("daodata1", data)
		return nil
	}

	resultFunc := func(ab *AbstractBusinessLogicHolder) (*interface{}, error) {
		return ab.GetFinalData(), nil
	}
	mb.SetCustomData("condition", false)
	ab, Err := GetSB("Test11Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL6, mb.ErrorFunction).
		AddStep("Step2", "$1 == true", nil, mb.BL7, mb.ErrorFunction).
		Run(resultFunc)

	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
	}
	assert.NoError(t, Err, "No Error Should be return")

}

func Test12Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		mb.SetResultset("daodata1", data)
		return nil
	}

	resultFunc := func(ab *AbstractBusinessLogicHolder) (*interface{}, error) {
		return ab.GetFinalData(), nil
	}
	mb.SetCustomData("condition", false)
Ajit Jagtap's avatar
Ajit Jagtap committed
	errormdl.IsTestingNegetiveCaseOnCheckBool = true
	ab, Err := GetSB("Test10Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL6, mb.ErrorFunction).
		AddStep("Step2", "$1 == true", nil, mb.BL7, mb.ErrorFunction).
		Run(resultFunc)
	errormdl.IsTestingNegetiveCaseOnCheckBool = false

	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
	}
	assert.NoError(t, Err, "No Error Should be return")

}

func Test13Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		mb.SetResultset("daodata1", data)
		return nil
	}

	resultFunc := func(ab *AbstractBusinessLogicHolder) (*interface{}, error) {
		return ab.GetFinalData(), nil
	}
	mb.SetCustomData("condition", false)
	errormdl.IsTestingNegetiveCaseOnCheckBool1 = true
	ab, Err := GetSB("Test10Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL6, mb.ErrorFunction).
		AddStep("Step2", "$1 == true", nil, mb.BL7, mb.ErrorFunction).
		Run(resultFunc)
Ajit Jagtap's avatar
Ajit Jagtap committed
	errormdl.IsTestingNegetiveCaseOnCheckBool1 = false

	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
Ajit Jagtap's avatar
Ajit Jagtap committed
	}
	assert.NoError(t, Err, "No Error Should be return")
Ajit Jagtap's avatar
Ajit Jagtap committed

func Test14Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		mb.SetResultset("daodata1", data)
		return nil
	}

	resultFunc := func(ab *AbstractBusinessLogicHolder) (*interface{}, error) {
		return ab.GetFinalData(), nil
	mb.SetCustomData("condition", false)
	ab, Err := GetSB("Test14Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL8, mb.ErrorFunction).
		AddStep("Step2", "$1 == true", nil, mb.BL9, mb.ErrorFunction).
		Run(resultFunc)

	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
	}
	assert.NoError(t, Err, "No Error Should be return")
func Test15Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		mb.SetResultset("daodata1", data)
		return nil
	}

	resultFunc := func(ab *AbstractBusinessLogicHolder) (*interface{}, error) {
		return ab.GetFinalData(), nil
	}
	mb.SetCustomData("condition", false)
	errormdl.IsTestingNegetiveCaseOnCheckBool = true
	_, Err := GetSB("Test15Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL8, mb.ErrorFunction).
		AddStep("Step2", "$1 == true", nil, mb.BL9, mb.ErrorFunction).
		Run(resultFunc)
	errormdl.IsTestingNegetiveCaseOnCheckBool = false
	if Err != nil {
		loggermdl.LogError(Err)
	}
	assert.NoError(t, Err, "No Error Should be return")

func Test16Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		mb.SetResultset("daodata1", data)
		return nil
	mb.SetCustomData("loginId", "roshanp1")
	ab, Err := GetSB("Test16Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL10, mb.ErrorFunction).
		Run(nil)
	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
	}
	assert.NoError(t, Err, "No Error Should be return")

}
Ajit Jagtap's avatar
Ajit Jagtap committed

func Test17Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		mb.SetResultset("daodata1", data)
		return nil
	mb.SetCustomData("loginId", "roshanp1")
	errormdl.IsTestingNegetiveCaseOnCheckBool = true
	ab, Err := GetSB("Test17Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL10, mb.ErrorFunction).
		Run(nil)
	errormdl.IsTestingNegetiveCaseOnCheckBool = false
	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
	}
	assert.NoError(t, Err, "No Error Should be return")

}

func Test18Service(t *testing.T) {
	mb := MyBLLayer{}
	mb.Build()

	loaddata := func(ab *AbstractBusinessLogicHolder) error {
		data, err := GetUsersInfo()
		if err != nil {
			loggermdl.LogError(err)
			return err
		}
		mb.SetResultset("daodata1", data)
		return nil
	}
	mb.SetCustomData("loginId", "roshanp1")
	errormdl.IsTestingNegetiveCaseOnCheckBool1 = true
	ab, Err := GetSB("Test17Service", &mb.AbstractBusinessLogicHolder).
		AddStep("Step1", "$1 == true", loaddata, mb.BL10, mb.ErrorFunction).
		Run(nil)
	errormdl.IsTestingNegetiveCaseOnCheckBool1 = false
	if Err != nil {
		loggermdl.LogError(Err)
	} else {
		ba, _ := json.Marshal(ab)
		loggermdl.LogInfo(string(ba))
	}
	assert.NoError(t, Err, "No Error Should be return")