func TestStatisticSimple(t *testing.T) {
option := options.SysOption{
Statistic: true, StatisticCheckTime: 2}
stat := statistic.NewStatistic(option)
outHandler := func(now time.Time, lines *[]string) {
for _, line := range *lines {
t.Log(line)
}
}
calcSummMethod := func(items *map[string]statistic.StatValueType) {
var sum statistic.StatValueType
if val, exists := (*items)["test1"]; exists {
sum += val
}
if val, exists := (*items)["test2"]; exists {
sum += val
}
(*items)["test3"] = sum
}
rllogger.SetSilent(true)
stat.AddStatisticOutHandler(outHandler)
stat.AddCalcHandler(calcSummMethod)
stat.AddItem("test1", "Test value 1")
stat.AddItem("test2", "Test value 2")
stat.AddItem("test3", "Test value 3")
stat.SendMsg("test2", 10)
stat.SendMsg("test1", 5.5)
time.Sleep(time.Duration(option.StatisticCheckTime+1) * time.Second)
stat.Close()
testData := statistic.TestingData(stat)
items := testData.GetTestingData()
if val, exists := (*items)["test3"]; !exists || val != 15.5 {
t.Error("Calculation problem!")
}
}
func TestUpdateStatusChanged(t *testing.T) {
option := options.SysOption{
Statistic: false}
var newStatus uint16 = 1
stat := statistic.NewStatistic(option)
handler := coreprocessing.NewHandler(1, option, stat)
inIns := coreprocessing.NewCoreInstruction(coreprocessing.TypeInstructionReg)
cmd := transport.NewCommand(0, "27d90e5e-0000000000000011-1", "statusupdate", fmt.Sprint(newStatus))
inIns.SetCommand(cmd)
outIns := coremethods.ProcUpdateStatus(handler, inIns)
if answer, exists := outIns.GetAnswer(); exists {
if (*answer).Error.Code > 0 {
t.Errorf(
"Answer has error with code: %d msg: %s.",
(*answer).Error.Code,
(*answer).Error.Message)
} else {
if outIns.StateChanges != nil {
if outIns.StateChanges.Status != newStatus {
t.Errorf("State change delegator has wrong status: %d.", outIns.StateChanges.Status)
}
} else {
t.Error("Empty state change delegator.")
}
}
} else {
t.Errorf("Empty answer to %s.", *cmd)
}
}
// ProcRegistration=>
//
func TestRegistrationEmptyParams(t *testing.T) {
option := options.SysOption{
Statistic: false}
stat := statistic.NewStatistic(option)
handler := coreprocessing.NewHandler(1, option, stat)
inIns := coreprocessing.NewCoreInstruction(coreprocessing.TypeInstructionReg)
cmd := transport.NewCommand(0, "27d90e5e-0000000000000011-1", "registration", "")
// expected methods as list of string
(*cmd).Params.Json = "{\"methods\": \"none\", \"group\": 1}"
inIns.SetCommand(cmd)
outIns := coremethods.ProcRegistration(handler, inIns)
if answer, exists := outIns.GetAnswer(); exists {
err := (*answer).Error.Code
if err > 0 {
t.Logf("Answer has error, %s.", (*answer).Error)
if err != transport.ErrorCodeMethodParamsFormatWrong {
t.Error("Unexpected error code: %d.", err)
}
} else {
t.Error("This answer must have error.")
}
} else {
t.Errorf("Empty answer to %s.", *cmd)
}
}
func TestRegistrationUnknownGroup(t *testing.T) {
option := options.SysOption{
Statistic: false}
stat := statistic.NewStatistic(option)
handler := coreprocessing.NewHandler(1, option, stat)
cheker := forTestConnectionStateCheck{Auth: true}
handler.StateCheker = &cheker
inIns := coreprocessing.NewCoreInstruction(coreprocessing.TypeInstructionReg)
cmd := transport.NewCommand(0, "27d90e5e-0000000000000011-1", "registration", "")
(*cmd).Params.Json = "{\"methods\": [\"none\"], \"group\": 4}"
inIns.SetCommand(cmd)
outIns := coremethods.ProcRegistration(handler, inIns)
if answer, exists := outIns.GetAnswer(); exists {
err := (*answer).Error.Code
if err > 0 {
t.Logf("Answer has error, %s.", (*answer).Error)
if err != transport.ErrorCodeUnexpectedValue {
t.Error("Unexpected error code: %d.", err)
}
} else {
t.Error("This answer must have error.")
}
} else {
t.Errorf("Empty answer to %s.", *cmd)
}
}
func Launch(option *options.SysOption) {
signalChannel := make(chan os.Signal, 1)
signal.Notify(signalChannel, os.Interrupt)
signal.Notify(signalChannel, syscall.SIGTERM)
coremethods.Setup()
mustExit := false
stat := statistic.NewStatistic(*option)
manager := coresupport.NewCoreWorkerManager(*option, stat)
server := connectionserver.NewServer(*option, stat)
server.Start(manager)
manager.Start(server)
// wait
for !mustExit {
select {
case newSig := <-signalChannel:
{
if newSig != nil {
rllogger.Output(rllogger.LogInfo, "Stoping service, now wait..")
server.Stop()
manager.Stop()
}
}
case <-manager.OutSignalChannel:
{
rllogger.Output(rllogger.LogInfo, "Close manager.")
mustExit = true
}
}
}
manager.Close()
stat.Close()
close(signalChannel)
}
// ProcUpdateStatus =>
//
func TestUpdateStatusEmptyParams(t *testing.T) {
option := options.SysOption{
Statistic: false}
stat := statistic.NewStatistic(option)
handler := coreprocessing.NewHandler(1, option, stat)
inIns := coreprocessing.NewCoreInstruction(coreprocessing.TypeInstructionReg)
cmd := transport.NewCommand(0, "27d90e5e-0000000000000011-1", "statusupdate", "")
inIns.SetCommand(cmd)
outIns := coremethods.ProcUpdateStatus(handler, inIns)
if answer, exists := outIns.GetAnswer(); exists {
if (*answer).Error.Code != transport.ErrorCodeMethodParamsFormatWrong {
t.Errorf("Answer hasn't error with code: %d.", transport.ErrorCodeMethodParamsFormatWrong)
}
} else {
t.Errorf("Empty answer to %s.", *cmd)
}
}
func TestRegistratioAddGroupClient(t *testing.T) {
option := options.SysOption{
Statistic: false}
stat := statistic.NewStatistic(option)
cid := "27d90e5e-0000000000000012-1"
handler := coreprocessing.NewHandler(1, option, stat)
cheker := forTestConnectionStateCheck{Auth: true}
handler.StateCheker = &cheker
inIns := coreprocessing.NewCoreInstruction(coreprocessing.TypeInstructionReg)
cmd := transport.NewCommand(0, cid, "registration", "")
(*cmd).Params.Json = fmt.Sprintf(
"{\"group\": %d}", connectionsupport.GroupConnectionClient)
inIns.SetCommand(cmd)
outIns := coremethods.ProcRegistration(handler, inIns)
if answer, exists := outIns.GetAnswer(); exists {
err := (*answer).Error.Code
if err > 0 {
t.Error("Answer with problem, %s", (*answer).Error)
} else {
stCh := (*outIns).StateChanges
if stCh != nil {
if (*stCh).ChangeType == connectionsupport.StateChangesTypeGroup {
if (*stCh).ConnectionClientGroup == connectionsupport.GroupConnectionClient {
if answer, exists := outIns.GetAnswer(); exists {
if (*answer).Result != "{\"ok\": true}" {
t.Errorf("Incorrect answer data: %s", (*answer).Result)
}
} else {
t.Error("Answer data is empty.")
}
} else {
t.Errorf("Incorrect connection group %s in changes.", (*stCh).ConnectionClientGroup)
}
} else {
t.Errorf("Type of changes is not a {}", connectionsupport.StateChangesTypeGroup)
}
} else {
t.Error("Changes empty.")
}
}
} else {
t.Errorf("Empty answer to %s.", *cmd)
}
}
func TestStatisticFileSave(t *testing.T) {
option := options.SysOption{
Statistic: true,
StatisticFile: fmt.Sprintf("%s/roolettest.stat.log", os.TempDir()),
StatisticCheckTime: 1}
t.Logf("Statistic file: %s", option.StatisticFile)
stat := statistic.NewStatistic(option)
calcSummMethod := func(items *map[string]statistic.StatValueType) {
var sum statistic.StatValueType
if val, exists := (*items)["test1"]; exists {
sum += val
}
if val, exists := (*items)["test2"]; exists {
sum += val
}
(*items)["test3"] = sum
}
rllogger.SetSilent(true)
stat.AddCalcHandler(calcSummMethod)
stat.AddItem("test1", "Test value 1")
stat.AddItem("test2", "Test value 2")
stat.AddItem("test3", "Test value 3")
stat.SendMsg("test2", 10)
stat.SendMsg("test1", 5.5)
time.Sleep(time.Duration(option.StatisticCheckTime+1) * time.Second)
stat.Close()
if file, err := os.Open(option.StatisticFile); err != nil {
t.Error(err)
} else {
if fi, err := file.Stat(); err != nil {
t.Error(err)
} else {
fSize := fi.Size()
t.Logf("File size: %d", fSize)
if fSize != 81 {
t.Error("Statistic file format changed??")
}
}
file.Close()
os.Remove(option.StatisticFile)
}
}
func TestUnexpectedClosingForAsyncClients(t *testing.T) {
option := options.SysOption{
Statistic: true, StatisticCheckTime: 2}
stat := statistic.NewStatistic(option)
outHandler := func(now time.Time, lines *[]string) {
for _, line := range *lines {
t.Log(line)
}
}
calcSummMethod := func(items *map[string]statistic.StatValueType) {
var sum statistic.StatValueType
if val, exists := (*items)["test1"]; exists {
sum += val
}
if val, exists := (*items)["test2"]; exists {
sum += val
}
(*items)["summ"] = sum
}
calcAvgMethod := func(items *map[string]statistic.StatValueType) {
var sum statistic.StatValueType
if val, exists := (*items)["test1"]; exists {
sum += val
}
if val, exists := (*items)["test2"]; exists {
sum += val
}
(*items)["avg"] = sum / 2.0
}
rllogger.SetSilent(true)
stat.AddStatisticOutHandler(outHandler)
stat.AddCalcHandler(calcSummMethod)
stat.AddCalcHandler(calcAvgMethod)
stat.AddItem("test1", "Test value 1")
stat.AddItem("test2", "Test value 2")
stat.AddItem("count", "count")
stat.AddItem("avg", "avg")
stat.AddItem("summ", "summ")
worker := func(st *statistic.Statistic, n int) {
for i := 0; i < n; i++ {
stat.SendMsg("test2", 1)
stat.SendMsg("test1", 0.1)
stat.SendMsg("test2", 0.1)
stat.SendMsg("test1", 1)
stat.SendMsg("count", 1)
}
}
for index := 0; index <= 64; index++ {
go worker(stat, 4000)
}
time.Sleep(time.Duration(100) * time.Millisecond)
stat.Close()
testData := statistic.TestingData(stat)
items := testData.GetTestingData()
if val, exists := (*items)["count"]; exists && val > 10 {
t.Logf("count = %d", int(val))
} else {
t.Error("some problem")
}
}
func TestRegistratioAddGroupServer(t *testing.T) {
option := options.SysOption{
Statistic: false}
stat := statistic.NewStatistic(option)
methodName := "test_test"
cid := "27d90e5e-0000000000000011-1"
handler := coreprocessing.NewHandler(1, option, stat)
cheker := forTestConnectionStateCheck{Auth: true}
handler.StateCheker = &cheker
inIns := coreprocessing.NewCoreInstruction(coreprocessing.TypeInstructionReg)
cmd := transport.NewCommand(0, cid, "registration", "")
(*cmd).Params.Json = fmt.Sprintf(
"{\"methods\": [\"%s\"], \"group\": %d}", methodName, connectionsupport.GroupConnectionServer)
inIns.SetCommand(cmd)
outIns := coremethods.ProcRegistration(handler, inIns)
if answer, exists := outIns.GetAnswer(); exists {
err := (*answer).Error.Code
if err > 0 {
t.Error("Answer with problem, %s", (*answer).Error)
} else {
stCh := (*outIns).StateChanges
if stCh != nil {
if (*stCh).ChangeType == connectionsupport.StateChangesTypeGroup {
if (*stCh).ConnectionClientGroup == connectionsupport.GroupConnectionServer {
cidMethods := coreprocessing.NewRpcServerManager()
cidList := cidMethods.GetCidVariants(methodName)
if len(cidList) > 0 {
exists := false
for _, variant := range cidList {
t.Logf("%s == %s ?", cid, variant)
if variant == cid {
exists = true
}
}
if exists {
// check answer
if answer, exists := outIns.GetAnswer(); exists {
if (*answer).Result != "{\"methods_count\": 1, \"ok\": true}" {
t.Errorf("Incorrect answer data: %s", (*answer).Result)
}
} else {
t.Error("Answer data is empty.")
}
} else {
t.Errorf("Not found cid '%s' for method '%s'.", cid, methodName)
}
} else {
t.Errorf("New cid '%s' lost for method '%s'.", cid, methodName)
}
} else {
t.Errorf("Incorrect connection group %s in changes.", (*stCh).ConnectionClientGroup)
}
} else {
t.Errorf("Type of changes is not a {}", connectionsupport.StateChangesTypeGroup)
}
} else {
t.Error("Changes empty.")
}
}
} else {
t.Errorf("Empty answer to %s.", *cmd)
}
}
