uppal/cgrates
1
0
Fork 1
mirror of https://github.com/cgrates/cgrates.git synced 2026-02-11 18:16:24 +05:00
Code Issues Packages Projects Releases Wiki Activity

Cover test + updated functions in server.go

Browse Source
This commit is contained in:
porosnicuadrian
2021-01-26 18:00:32 +02:00
committed by Dan Christian Bogos
parent ac5ad43ddb
commit 464691913b
5 changed files with 407 additions and 186 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
cores/caps_test.go
View File

@@ -38,7 +38,7 @@ func (c *mockServerCodec) ReadRequestHeader(r *rpc.Request) (err error) {
}
func (c *mockServerCodec) ReadRequestBody(x interface{}) (err error) {
return
return utils.ErrNotImplemented
}
func (c *mockServerCodec) WriteResponse(r *rpc.Response, x interface{}) error {
return nil
@@ -72,7 +72,7 @@ func TestNewCapsServerCodec(t *testing.T) {
t.Errorf("Expected: %v ,received:%v", expR, r)
}
if err = codec.ReadRequestBody("args"); err != nil {
if err = codec.ReadRequestBody("args"); err == nil || err != utils.ErrNotImplemented {
t.Fatal(err)
}

5
cores/core_test.go
View File

@@ -32,13 +32,12 @@ func TestNewCoreService(t *testing.T) {
cfgDflt := config.NewDefaultCGRConfig()
cfgDflt.CoreSCfg().CapsStatsInterval = 1
caps := engine.NewCaps(1, utils.MetaBusy)
stopChan := make(chan struct{}, 1)
sts := engine.NewCapsStats(cfgDflt.CoreSCfg().CapsStatsInterval, caps, stopChan)
sts := engine.NewCapsStats(cfgDflt.CoreSCfg().CapsStatsInterval, caps, nil)
expected := &CoreService{
cfg: cfgDflt,
CapsStats: sts,
}
rcv := NewCoreService(cfgDflt, caps, stopChan)
rcv := NewCoreService(cfgDflt, caps, nil)
if !reflect.DeepEqual(expected, rcv) {
t.Errorf("Expected %+v, received %+v", utils.ToJSON(expected), utils.ToJSON(rcv))
}

87
cores/server.go
View File

@@ -22,6 +22,7 @@ import (
"bytes"
"crypto/tls"
"crypto/x509"
"errors"
"fmt"
"io"
"io/ioutil"
@@ -360,12 +361,13 @@ func loadTLSConfig(serverCrt, serverKey, caCert string, serverPolicy int,
serverName string) (config *tls.Config, err error) {
cert, err := tls.LoadX509KeyPair(serverCrt, serverKey)
if err != nil {
log.Fatalf("Error: %s when load server keys", err)
utils.Logger.Crit(fmt.Sprintf("Error: %s when load server keys", err))
return nil, err
}
rootCAs, err := x509.SystemCertPool()
if err != nil {
log.Fatalf("Error: %s when load SystemCertPool", err)
return
utils.Logger.Crit(fmt.Sprintf("Error: %s when load SystemCertPool", err))
return nil, err
}
if rootCAs == nil {
rootCAs = x509.NewCertPool()
@@ -374,13 +376,13 @@ func loadTLSConfig(serverCrt, serverKey, caCert string, serverPolicy int,
if caCert != "" {
ca, err := ioutil.ReadFile(caCert)
if err != nil {
log.Fatalf("Error: %s when read CA", err)
utils.Logger.Crit(fmt.Sprintf("Error: %s when read CA", err))
return config, err
}
if ok := rootCAs.AppendCertsFromPEM(ca); !ok {
log.Fatalf("Cannot append certificate authority")
return config, err
utils.Logger.Crit(fmt.Sprintf("Cannot append certificate authority"))
return config, errors.New("Cannot append certificate authority")
}
}
@@ -395,8 +397,9 @@ func loadTLSConfig(serverCrt, serverKey, caCert string, serverPolicy int,
return
}
func (s *Server) ServeGOBTLS(addr, serverCrt, serverKey, caCert string,
serverPolicy int, serverName string, shdChan *utils.SyncedChan) {
func (s *Server) serveCodecTLS(addr, codecName, serverCrt, serverKey, caCert string,
serverPolicy int, serverName string, newCodec func(conn conn, caps *engine.Caps, anz *analyzers.AnalyzerService) rpc.ServerCodec,
shdChan *utils.SyncedChan) {
s.RLock()
enabled := s.rpcEnabled
s.RUnlock()
@@ -414,72 +417,18 @@ func (s *Server) ServeGOBTLS(addr, serverCrt, serverKey, caCert string,
shdChan.CloseOnce()
return
}
utils.Logger.Info(fmt.Sprintf("Starting CGRateS %s TLS server at <%s>.", codecName, addr))
s.accept(listener, codecName+" "+utils.TLS, newCodec, shdChan)
}
utils.Logger.Info(fmt.Sprintf("Starting CGRateS GOB TLS server at <%s>.", addr))
errCnt := 0
var lastErrorTime time.Time
for {
conn, err := listener.Accept()
defer conn.Close()
if err != nil {
utils.Logger.Err(fmt.Sprintf("<CGRServer> TLS accept error: <%s>", err.Error()))
now := time.Now()
if now.Sub(lastErrorTime) > 5*time.Second {
errCnt = 0 // reset error count if last error was more than 5 seconds ago
}
lastErrorTime = time.Now()
errCnt++
if errCnt > 50 { // Too many errors in short interval, network buffer failure most probably
shdChan.CloseOnce()
return
}
continue
}
go rpc.ServeCodec(newCapsGOBCodec(conn, s.caps, s.anz))
}
func (s *Server) ServeGOBTLS(addr, serverCrt, serverKey, caCert string,
serverPolicy int, serverName string, shdChan *utils.SyncedChan) {
s.serveCodecTLS(addr, utils.GOBCaps, serverCrt, serverKey, caCert, serverPolicy, serverName, newCapsGOBCodec, shdChan)
}
func (s *Server) ServeJSONTLS(addr, serverCrt, serverKey, caCert string,
serverPolicy int, serverName string, shdChan *utils.SyncedChan) {
s.RLock()
enabled := s.rpcEnabled
s.RUnlock()
if !enabled {
return
}
config, err := loadTLSConfig(serverCrt, serverKey, caCert, serverPolicy, serverName)
if err != nil {
shdChan.CloseOnce()
return
}
listener, err := tls.Listen(utils.TCP, addr, config)
if err != nil {
log.Println(fmt.Sprintf("Error: %s when listening", err))
shdChan.CloseOnce()
return
}
utils.Logger.Info(fmt.Sprintf("Starting CGRateS JSON TLS server at <%s>.", addr))
errCnt := 0
var lastErrorTime time.Time
for {
conn, err := listener.Accept()
defer conn.Close()
if err != nil {
utils.Logger.Err(fmt.Sprintf("<CGRServer> TLS accept error: <%s>", err.Error()))
now := time.Now()
if now.Sub(lastErrorTime) > 5*time.Second {
errCnt = 0 // reset error count if last error was more than 5 seconds ago
}
lastErrorTime = time.Now()
errCnt++
if errCnt > 50 { // Too many errors in short interval, network buffer failure most probably
shdChan.CloseOnce()
return
}
continue
}
go rpc.ServeCodec(newCapsJSONCodec(conn, s.caps, s.anz))
}
s.serveCodecTLS(addr, utils.JSONCaps, serverCrt, serverKey, caCert, serverPolicy, serverName, newCapsJSONCodec, shdChan)
}
func (s *Server) ServeHTTPTLS(addr, serverCrt, serverKey, caCert string, serverPolicy int,

406
cores/server_it_test.go
View File

@@ -1,4 +1,5 @@
// +build integration
/*
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
Copyright (C) ITsysCOM GmbH
@@ -20,9 +21,19 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package cores
import (
"bytes"
"io/ioutil"
"log"
"net"
"net/http"
"net/http/httptest"
"net/rpc/jsonrpc"
"os"
"path"
"runtime"
"strings"
"testing"
"time"
sessions2 "github.com/cgrates/cgrates/sessions"
@@ -39,10 +50,11 @@ var (
server *Server
sTestsServer = []func(t *testing.T){
testServeJSONPass,
testServeGOBPortFail,
testServeJSON,
testServeJSONFail,
testServeJSONFailRpcEnabled,
testServeGOBPass,
testServeGOB,
testServeHHTPPass,
testServeHHTPPassUseBasicAuth,
testServeHHTPEnableHttp,
@@ -51,11 +63,23 @@ var (
testServeBiJSON,
testServeBiJSONEmptyBiRPCServer,
testServeBiJSONInvalidPort,
testServeGOBTLS,
testServeJSONTls,
testServeCodecTLSErr,
testLoadTLSConfigErr,
testServeHTTPTLS,
testServeHTTPTLSWithBasicAuth,
testServeHTTPTLSError,
testServeHTTPTLSHttpNotEnabled,
testHandleRequest,
testBiRPCRegisterName,
}
)
func TestServerIT(t *testing.T) {
utils.Logger.SetLogLevel(7)
for _, test := range sTestsServer {
log.SetOutput(ioutil.Discard)
t.Run("Running IT serve tests", test)
}
}
@@ -67,22 +91,64 @@ func (robj *mockRegister) Ping(in string, out *string) error {
return nil
}
type mockListener struct{}
type mockListener struct {
p1 net.Conn
call bool
}
func (mkL *mockListener) Accept() (net.Conn, error) { return nil, utils.ErrDisconnected }
func (mkL *mockListener) Close() error { return nil }
func (mkL *mockListener) Addr() net.Addr { return nil }
func (mkL *mockListener) Accept() (net.Conn, error) {
if !mkL.call {
mkL.call = true
return mkL.p1, nil
}
return nil, utils.ErrDisconnected
}
func testServeJSONPass(t *testing.T) {
func (mkL *mockListener) Close() error { return mkL.p1.Close() }
func (mkL *mockListener) Addr() net.Addr { return nil }
func testHandleRequest(t *testing.T) {
cfgDflt := config.NewDefaultCGRConfig()
cfgDflt.CoreSCfg().CapsStatsInterval = 1
caps := engine.NewCaps(0, utils.MetaBusy)
rcv := NewServer(caps)
rcv.rpcEnabled = true
req, err := http.NewRequest(http.MethodPost, "http://127.0.0.1:2080/json_rpc",
bytes.NewBuffer([]byte("1")))
if err != nil {
t.Fatal(err)
}
w := httptest.NewRecorder()
rcv.handleRequest(w, req)
if w.Body.String() != utils.EmptyString {
t.Errorf("Expected: %q ,received: %q", utils.EmptyString, w.Body.String())
}
rcv.StopBiRPC()
}
func testServeJSON(t *testing.T) {
caps := engine.NewCaps(100, utils.MetaBusy)
server = NewServer(caps)
server.RpcRegister(new(mockRegister))
shdChan := utils.NewSyncedChan()
go server.ServeJSON(":2016", shdChan)
buff := new(bytes.Buffer)
log.SetOutput(buff)
go server.ServeJSON(":88845", shdChan)
runtime.Gosched()
expected := "listen tcp: address 88845: invalid port"
if rcv := buff.String(); !strings.Contains(rcv, expected) {
t.Errorf("Expected %+v, received %+v", expected, rcv)
}
shdChan.CloseOnce()
server.StopBiRPC()
}
func testServeJSONFail(t *testing.T) {
@@ -91,13 +157,21 @@ func testServeJSONFail(t *testing.T) {
server.RpcRegister(new(mockRegister))
shdChan := utils.NewSyncedChan()
l := &mockListener{}
p1, p2 := net.Pipe()
l := &mockListener{
p1: p1,
}
go server.accept(l, utils.JSONCaps, newCapsJSONCodec, shdChan)
runtime.Gosched()
_, ok := <-shdChan.Done()
if ok {
t.Errorf("Expected to be close")
}
p2.Close()
runtime.Gosched()
shdChan.CloseOnce()
server.StopBiRPC()
}
func testServeJSONFailRpcEnabled(t *testing.T) {
@@ -108,20 +182,23 @@ func testServeJSONFailRpcEnabled(t *testing.T) {
server.rpcEnabled = false
go server.serveCodec(":9999", utils.JSONCaps, newCapsJSONCodec, shdChan)
runtime.Gosched()
shdChan.CloseOnce()
server.StopBiRPC()
}
func testServeGOBPass(t *testing.T) {
func testServeGOB(t *testing.T) {
caps := engine.NewCaps(100, utils.MetaBusy)
server = NewServer(caps)
server.RpcRegister(new(mockRegister))
shdChan := utils.NewSyncedChan()
go server.ServeGOB(":2019", shdChan)
go server.ServeGOB(":27697", shdChan)
runtime.Gosched()
shdChan.CloseOnce()
server.StopBiRPC()
}
func testServeHHTPPass(t *testing.T) {
@@ -132,7 +209,7 @@ func testServeHHTPPass(t *testing.T) {
shdChan := utils.NewSyncedChan()
go server.ServeHTTP(
":2021",
":6555",
cfgDflt.HTTPCfg().HTTPJsonRPCURL,
cfgDflt.HTTPCfg().HTTPWSURL,
cfgDflt.HTTPCfg().HTTPUseBasicAuth,
@@ -142,6 +219,7 @@ func testServeHHTPPass(t *testing.T) {
runtime.Gosched()
shdChan.CloseOnce()
server.StopBiRPC()
}
func testServeHHTPPassUseBasicAuth(t *testing.T) {
@@ -152,7 +230,7 @@ func testServeHHTPPassUseBasicAuth(t *testing.T) {
shdChan := utils.NewSyncedChan()
go server.ServeHTTP(
":2075",
":56432",
cfgDflt.HTTPCfg().HTTPJsonRPCURL,
cfgDflt.HTTPCfg().HTTPWSURL,
!cfgDflt.HTTPCfg().HTTPUseBasicAuth,
@@ -162,6 +240,7 @@ func testServeHHTPPassUseBasicAuth(t *testing.T) {
runtime.Gosched()
shdChan.CloseOnce()
server.StopBiRPC()
}
func testServeHHTPEnableHttp(t *testing.T) {
@@ -172,7 +251,7 @@ func testServeHHTPEnableHttp(t *testing.T) {
shdChan := utils.NewSyncedChan()
go server.ServeHTTP(
":2077",
":45779",
utils.EmptyString,
utils.EmptyString,
!cfgDflt.HTTPCfg().HTTPUseBasicAuth,
@@ -182,6 +261,7 @@ func testServeHHTPEnableHttp(t *testing.T) {
runtime.Gosched()
shdChan.CloseOnce()
server.StopBiRPC()
}
func testServeHHTPFail(t *testing.T) {
@@ -205,6 +285,7 @@ func testServeHHTPFail(t *testing.T) {
if ok {
t.Errorf("Expected to be close")
}
server.StopBiRPC()
}
func testServeHHTPFailEnableRpc(t *testing.T) {
@@ -223,6 +304,7 @@ func testServeHHTPFailEnableRpc(t *testing.T) {
shdChan)
shdChan.CloseOnce()
server.StopBiRPC()
}
func testServeBiJSON(t *testing.T) {
@@ -242,7 +324,6 @@ func testServeBiJSON(t *testing.T) {
t.Error(err)
}
}()
runtime.Gosched()
}
@@ -259,7 +340,6 @@ func testServeBiJSONEmptyBiRPCServer(t *testing.T) {
expectedErr := "BiRPCServer should not be nil"
go func() {
if err := server.ServeBiJSON(":3430", sessions.OnBiJSONConnect, sessions.OnBiJSONDisconnect); err == nil || err.Error() != "BiRPCServer should not be nil" {
t.Errorf("Expected %+v, received %+v", expectedErr, err)
}
@@ -285,29 +365,307 @@ func testServeBiJSONInvalidPort(t *testing.T) {
sessions.OnBiJSONDisconnect); err == nil || err.Error() != expectedErr {
t.Errorf("Expected %+v, received %+v", expectedErr, err)
}
server.StopBiRPC()
}
/*
func testServeGOBTLS(t *testing.T) {
cfgDflt := config.NewDefaultCGRConfig()
caps := engine.NewCaps(100, utils.MetaBusy)
server = NewServer(caps)
server.RpcRegister(new(randomObj))
server.RpcRegister(new(mockRegister))
shdChan := utils.NewSyncedChan()
go server.ServeGOBTLS(
":1256",
cfgDflt.TLSCfg().ServerCerificate,
cfgDflt.TLSCfg().ServerKey,
cfgDflt.TLSCfg().CaCertificate,
cfgDflt.TLSCfg().ServerPolicy,
":34476",
"/usr/share/cgrates/tls/server.crt",
"/usr/share/cgrates/tls/server.key",
"/usr/share/cgrates/tls/ca.crt",
4,
cfgDflt.TLSCfg().ServerName,
shdChan,
)
runtime.Gosched()
server.StopBiRPC()
}
func testServeJSONTls(t *testing.T) {
cfgDflt := config.NewDefaultCGRConfig()
caps := engine.NewCaps(100, utils.MetaBusy)
server = NewServer(caps)
server.RpcRegister(new(mockRegister))
shdChan := utils.NewSyncedChan()
go server.ServeJSONTLS(
":64779",
"/usr/share/cgrates/tls/server.crt",
"/usr/share/cgrates/tls/server.key",
"/usr/share/cgrates/tls/ca.crt",
4,
cfgDflt.TLSCfg().ServerName,
shdChan,
)
runtime.Gosched()
}
func testServeGOBPortFail(t *testing.T) {
caps := engine.NewCaps(100, utils.MetaBusy)
server = NewServer(caps)
server.RpcRegister(new(mockRegister))
shdChan := utils.NewSyncedChan()
buff := new(bytes.Buffer)
log.SetOutput(buff)
go server.serveCodecTLS(
"34776",
utils.GOBCaps,
"/usr/share/cgrates/tls/server.crt",
"/usr/share/cgrates/tls/server.key",
"/usr/share/cgrates/tls/ca.crt",
4,
"Server_name",
newCapsGOBCodec,
shdChan,
)
runtime.Gosched()
select {
case <-time.After(10 * time.Second):
t.Fatal("timeout")
case <-shdChan.Done():
}
expected := "listen tcp: address 34776: missing port in address when listening"
if rcv := buff.String(); !strings.Contains(rcv, expected) {
t.Errorf("Expected %+v, received %+v", expected, rcv)
}
log.SetOutput(os.Stderr)
}
func testServeCodecTLSErr(t *testing.T) {
cfgDflt := config.NewDefaultCGRConfig()
caps := engine.NewCaps(100, utils.MetaBusy)
server = NewServer(caps)
server.RpcRegister(new(mockRegister))
shdChan := utils.NewSyncedChan()
//if rpc is not enabled, won t be able to serve
server.rpcEnabled = false
server.serveCodecTLS("13567",
utils.GOBCaps,
"/usr/share/cgrates/tls/server.crt",
"/usr/share/cgrates/tls/server.key",
"/usr/share/cgrates/tls/ca.crt",
4,
cfgDflt.TLSCfg().ServerName,
newCapsGOBCodec,
shdChan)
//unable to load TLS config when there is an inexisting server certificate file
server.rpcEnabled = true
server.serveCodecTLS("13567",
utils.GOBCaps,
"/usr/share/cgrates/tls/inexisting_cert",
"/usr/share/cgrates/tls/server.key",
"/usr/share/cgrates/tls/ca.crt",
4,
cfgDflt.TLSCfg().ServerName,
newCapsGOBCodec,
shdChan)
_, ok := <-shdChan.Done()
if ok {
t.Errorf("Expected to be close")
}
}
func testLoadTLSConfigErr(t *testing.T) {
flPath := "/tmp/testLoadTLSConfigErr1"
if err := os.MkdirAll(flPath, 0777); err != nil {
t.Error(err)
}
file, err := os.Create(path.Join(flPath, "file.txt"))
if err != nil {
t.Error(err)
}
file.Write([]byte(`
TEST
`))
file.Close()
caps := engine.NewCaps(100, utils.MetaBusy)
server = NewServer(caps)
server.RpcRegister(new(mockRegister))
expectedErr := "Cannot append certificate authority"
if _, err := loadTLSConfig(
"/usr/share/cgrates/tls/server.crt",
"/usr/share/cgrates/tls/server.key",
path.Join(flPath, "file.txt"),
0,
utils.EmptyString); err == nil || err.Error() != expectedErr {
t.Errorf("Expected %+v, received %+v", expectedErr, err)
}
expectedErr = "open /tmp/testLoadTLSConfigErr1/file1.txt: no such file or directory"
if _, err := loadTLSConfig(
"/usr/share/cgrates/tls/server.crt",
"/usr/share/cgrates/tls/server.key",
path.Join(flPath, "file1.txt"),
0,
utils.EmptyString); err == nil || err.Error() != expectedErr {
t.Errorf("Expected %+v, received %+v", expectedErr, err)
}
if err := os.Remove(path.Join(flPath, "file.txt")); err != nil {
t.Error(err)
} else if err := os.Remove(flPath); err != nil {
t.Error(err)
}
}
func testServeHTTPTLS(t *testing.T) {
cfgDflt := config.NewDefaultCGRConfig()
caps := engine.NewCaps(100, utils.MetaBusy)
server = NewServer(caps)
server.RpcRegister(new(mockRegister))
shdChan := utils.NewSyncedChan()
//cannot serve HHTPTls when rpc is not enabled
server.rpcEnabled = false
server.ServeHTTPTLS(
"17789",
"/usr/share/cgrates/tls/server.crt",
"/usr/share/cgrates/tls/server.key",
"/usr/share/cgrates/tls/ca.crt",
cfgDflt.TLSCfg().ServerPolicy,
cfgDflt.TLSCfg().ServerName,
cfgDflt.HTTPCfg().HTTPJsonRPCURL,
cfgDflt.HTTPCfg().HTTPWSURL,
cfgDflt.HTTPCfg().HTTPUseBasicAuth,
cfgDflt.HTTPCfg().HTTPAuthUsers,
shdChan)
//Invalid port address
server.rpcEnabled = true
go server.ServeHTTPTLS(
"17789",
"/usr/share/cgrates/tls/server.crt",
"/usr/share/cgrates/tls/server.key",
"/usr/share/cgrates/tls/ca.crt",
cfgDflt.TLSCfg().ServerPolicy,
cfgDflt.TLSCfg().ServerName,
cfgDflt.HTTPCfg().HTTPJsonRPCURL,
cfgDflt.HTTPCfg().HTTPWSURL,
cfgDflt.HTTPCfg().HTTPUseBasicAuth,
cfgDflt.HTTPCfg().HTTPAuthUsers,
shdChan)
runtime.Gosched()
_, ok := <-shdChan.Done()
if ok {
t.Errorf("Expected to be close")
}
}
func testServeHTTPTLSWithBasicAuth(t *testing.T) {
cfgDflt := config.NewDefaultCGRConfig()
caps := engine.NewCaps(100, utils.MetaBusy)
server = NewServer(caps)
server.RpcRegister(new(mockRegister))
shdChan := utils.NewSyncedChan()
//Invalid port address
server.rpcEnabled = true
go server.ServeHTTPTLS(
"57235",
"/usr/share/cgrates/tls/server.crt",
"/usr/share/cgrates/tls/server.key",
"/usr/share/cgrates/tls/ca.crt",
cfgDflt.TLSCfg().ServerPolicy,
cfgDflt.TLSCfg().ServerName,
cfgDflt.HTTPCfg().HTTPJsonRPCURL,
cfgDflt.HTTPCfg().HTTPWSURL,
!cfgDflt.HTTPCfg().HTTPUseBasicAuth,
cfgDflt.HTTPCfg().HTTPAuthUsers,
shdChan)
runtime.Gosched()
_, ok := <-shdChan.Done()
if ok {
t.Errorf("Expected to be close")
}
}
func testServeHTTPTLSError(t *testing.T) {
cfgDflt := config.NewDefaultCGRConfig()
caps := engine.NewCaps(100, utils.MetaBusy)
server = NewServer(caps)
server.RpcRegister(new(mockRegister))
shdChan := utils.NewSyncedChan()
//Invalid port address
go server.ServeHTTPTLS(
"57235",
"/usr/share/cgrates/tls/inexisting_file",
"/usr/share/cgrates/tls/server.key",
"/usr/share/cgrates/tls/ca.crt",
cfgDflt.TLSCfg().ServerPolicy,
cfgDflt.TLSCfg().ServerName,
cfgDflt.HTTPCfg().HTTPJsonRPCURL,
cfgDflt.HTTPCfg().HTTPWSURL,
!cfgDflt.HTTPCfg().HTTPUseBasicAuth,
cfgDflt.HTTPCfg().HTTPAuthUsers,
shdChan)
runtime.Gosched()
_, ok := <-shdChan.Done()
if ok {
t.Errorf("Expected to be close")
}
}
func testServeHTTPTLSHttpNotEnabled(t *testing.T) {
cfgDflt := config.NewDefaultCGRConfig()
caps := engine.NewCaps(100, utils.MetaBusy)
server = NewServer(caps)
server.RpcRegister(new(mockRegister))
shdChan := utils.NewSyncedChan()
server.httpEnabled = false
go server.ServeHTTPTLS(
"17789",
"/usr/share/cgrates/tls/server.crt",
"/usr/share/cgrates/tls/server.key",
"/usr/share/cgrates/tls/ca.crt",
cfgDflt.TLSCfg().ServerPolicy,
cfgDflt.TLSCfg().ServerName,
utils.EmptyString,
utils.EmptyString,
cfgDflt.HTTPCfg().HTTPUseBasicAuth,
cfgDflt.HTTPCfg().HTTPAuthUsers,
shdChan)
shdChan.CloseOnce()
}
*/
func testBiRPCRegisterName(t *testing.T) {
caps := engine.NewCaps(0, utils.MetaBusy)
server := NewServer(caps)
handler := func(method *rpc2.Client, args *interface{}, reply *interface{}) error {
return nil
}
go server.BiRPCRegisterName(utils.APIerSv1Ping, handler)
runtime.Gosched()
server.StopBiRPC()
}

91
cores/server_test.go
View File

@@ -19,17 +19,15 @@ along with this program. If not, see <http://www.gnu.org/licenses/>
package cores
import (
"bytes"
"io/ioutil"
"log"
"net/http"
"net/http/httptest"
"os"
"reflect"
"testing"
"github.com/cenkalti/rpc2"
"github.com/cgrates/cgrates/agents"
"github.com/cgrates/cgrates/analyzers"
"github.com/cgrates/cgrates/config"
@@ -64,34 +62,8 @@ func TestNewServer(t *testing.T) {
}
}
func TestServerRpcRrgister(t *testing.T) {
cfgDflt := config.NewDefaultCGRConfig()
cfgDflt.CoreSCfg().CapsStatsInterval = 1
caps := engine.NewCaps(0, utils.MetaBusy)
rcv := NewServer(caps)
cfgDflt.AnalyzerSCfg().DBPath = "/tmp/analyzers"
if err := os.RemoveAll(cfgDflt.AnalyzerSCfg().DBPath); err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(cfgDflt.AnalyzerSCfg().DBPath, 0700); err != nil {
t.Fatal(err)
}
analz, err := analyzers.NewAnalyzerService(cfgDflt)
if err != nil {
t.Error(err)
}
rcv.SetAnalyzer(analz)
rcv.RpcRegister(utils.EmptyString)
if err := os.RemoveAll(cfgDflt.AnalyzerSCfg().DBPath); err != nil {
t.Fatal(err)
}
rcv.StopBiRPC()
}
func TestRegisterHttpFunc(t *testing.T) {
log.SetOutput(ioutil.Discard)
cfgDflt := config.NewDefaultCGRConfig()
cfgDflt.CoreSCfg().CapsStatsInterval = 1
caps := engine.NewCaps(0, utils.MetaBusy)
@@ -157,40 +129,6 @@ func TestBiRPCRegisterName(t *testing.T) {
rcv.StopBiRPC()
}
func TestServeJSONAndGob(t *testing.T) {
cfgDflt := config.NewDefaultCGRConfig()
cfgDflt.CoreSCfg().CapsStatsInterval = 1
caps := engine.NewCaps(0, utils.MetaBusy)
rcv := NewServer(caps)
cfgDflt.AnalyzerSCfg().DBPath = "/tmp/analyzers"
if err := os.RemoveAll(cfgDflt.AnalyzerSCfg().DBPath); err != nil {
t.Fatal(err)
}
if err := os.MkdirAll(cfgDflt.AnalyzerSCfg().DBPath, 0700); err != nil {
t.Fatal(err)
}
analz, err := analyzers.NewAnalyzerService(cfgDflt)
if err != nil {
t.Error(err)
}
rcv.SetAnalyzer(analz)
rcv.rpcEnabled = true
shdChan := utils.NewSyncedChan()
//cannot accept the listener
rcv.ServeJSON("8080", shdChan)
//cannot accept the listener
rcv.ServeGOB("2015", shdChan)
if err := os.RemoveAll(cfgDflt.AnalyzerSCfg().DBPath); err != nil {
t.Fatal(err)
}
rcv.StopBiRPC()
}
func TestRegisterProfiler(t *testing.T) {
cfgDflt := config.NewDefaultCGRConfig()
cfgDflt.CoreSCfg().CapsStatsInterval = 1
@@ -203,26 +141,3 @@ func TestRegisterProfiler(t *testing.T) {
rcv.StopBiRPC()
}
func TestHandleRequest(t *testing.T) {
cfgDflt := config.NewDefaultCGRConfig()
cfgDflt.CoreSCfg().CapsStatsInterval = 1
caps := engine.NewCaps(0, utils.MetaBusy)
rcv := NewServer(caps)
rcv.rpcEnabled = true
req, err := http.NewRequest(http.MethodPost, "https://raw.githubusercontent.com/cgrates/cgrates/master/data/tariffplans/oldtutorial/ActionPlans.csv",
bytes.NewBuffer([]byte("1")))
if err != nil {
t.Fatal(err)
}
w := httptest.NewRecorder()
rcv.handleRequest(w, req)
if w.Body.String() != utils.EmptyString {
t.Errorf("Expected: %q ,received: %q", utils.EmptyString, w.Body.String())
}
rcv.StopBiRPC()
}