From 464691913bb7fcd76a98c865cf475b9db6c5cdc1 Mon Sep 17 00:00:00 2001 From: porosnicuadrian Date: Tue, 26 Jan 2021 18:00:32 +0200 Subject: [PATCH] Cover test + updated functions in server.go --- cores/caps_test.go | 4 +- cores/core_test.go | 5 +- cores/server.go | 87 ++------- cores/server_it_test.go | 406 +++++++++++++++++++++++++++++++++++++--- cores/server_test.go | 91 +-------- 5 files changed, 407 insertions(+), 186 deletions(-) diff --git a/cores/caps_test.go b/cores/caps_test.go index 8f375cebe..89ab1068f 100644 --- a/cores/caps_test.go +++ b/cores/caps_test.go @@ -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) } diff --git a/cores/core_test.go b/cores/core_test.go index ad27c09e8..7c67d5ace 100644 --- a/cores/core_test.go +++ b/cores/core_test.go @@ -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)) } diff --git a/cores/server.go b/cores/server.go index fd67c0913..8e13632de 100644 --- a/cores/server.go +++ b/cores/server.go @@ -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(" 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(" 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, diff --git a/cores/server_it_test.go b/cores/server_it_test.go index 933968759..1bb95bbfc 100644 --- a/cores/server_it_test.go +++ b/cores/server_it_test.go @@ -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 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() +} diff --git a/cores/server_test.go b/cores/server_test.go index bd7c9e843..e6b53cb3a 100644 --- a/cores/server_test.go +++ b/cores/server_test.go @@ -19,17 +19,15 @@ along with this program. If not, see 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() -}