mirror of
https://github.com/cgrates/cgrates.git
synced 2026-02-11 18:16:24 +05:00
440 lines
8.3 KiB
Go
440 lines
8.3 KiB
Go
/*
|
|
Real-time Online/Offline Charging System (OCS) for Telecom & ISP environments
|
|
Copyright (C) ITsysCOM GmbH
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 3 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>
|
|
*/
|
|
|
|
package utils
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/json"
|
|
"fmt"
|
|
"io"
|
|
"net/rpc"
|
|
"reflect"
|
|
"testing"
|
|
)
|
|
|
|
func TestNewCustomJSONServerCodec(t *testing.T) {
|
|
|
|
reader, writer := io.Pipe()
|
|
|
|
codec := NewCustomJSONServerCodec(struct {
|
|
io.Reader
|
|
io.Writer
|
|
io.Closer
|
|
}{Reader: reader, Writer: writer, Closer: writer})
|
|
|
|
c := codec.(*jsonServerCodec)
|
|
|
|
if c.dec == nil {
|
|
t.Error("Decoder is nil")
|
|
}
|
|
if c.enc == nil {
|
|
t.Error("Encoder is nil")
|
|
}
|
|
if c.c == nil {
|
|
t.Error("Connection is nil")
|
|
}
|
|
if c.pending == nil {
|
|
t.Error("Pending map is nil")
|
|
}
|
|
|
|
writer.Close()
|
|
}
|
|
|
|
func TestJSONCodecReset(t *testing.T) {
|
|
|
|
r := serverRequest{
|
|
Method: "test",
|
|
Params: &json.RawMessage{},
|
|
Id: &json.RawMessage{},
|
|
isApier: false,
|
|
}
|
|
|
|
r.reset()
|
|
|
|
if r.Method != "" {
|
|
t.Error("Method didn't clear")
|
|
}
|
|
if r.Params != nil {
|
|
t.Error("Params didn't clear")
|
|
}
|
|
if r.Id != nil {
|
|
t.Error("Id didn't clear")
|
|
}
|
|
}
|
|
|
|
type bufferClose struct {
|
|
*bytes.Buffer
|
|
}
|
|
|
|
func (b *bufferClose) Close() error {
|
|
return nil
|
|
}
|
|
|
|
func TestJSONCodecReadRequestHeader2(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
write []byte
|
|
exp error
|
|
}{
|
|
{
|
|
name: "ValidRequest",
|
|
write: []byte(`{
|
|
"method": "APIerSv1.RemTP",
|
|
"params": [{
|
|
"TPid": "test"
|
|
}],
|
|
"id": 0
|
|
}`),
|
|
exp: nil,
|
|
},
|
|
{
|
|
name: "InvalidRequest",
|
|
write: []byte("test"),
|
|
exp: fmt.Errorf("invalid character 'e' in literal true (expecting 'r')"),
|
|
},
|
|
{
|
|
name: "ValidApierRequest",
|
|
write: []byte(`{
|
|
"method": "ApierV.Method",
|
|
"params": [{
|
|
"TPid": "test"
|
|
}],
|
|
"id": 0
|
|
}`),
|
|
exp: nil,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
conn := &bufferClose{
|
|
Buffer: &bytes.Buffer{},
|
|
}
|
|
s := NewCustomJSONServerCodec(conn)
|
|
|
|
rr := rpc.Request{
|
|
ServiceMethod: "Service.Method",
|
|
Seq: 1,
|
|
}
|
|
|
|
conn.Write(tt.write)
|
|
|
|
err := s.ReadRequestHeader(&rr)
|
|
if err != nil {
|
|
if err.Error() != tt.exp.Error() {
|
|
t.Errorf("Received an error: %v", err)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestJSONReadRequestBody(t *testing.T) {
|
|
|
|
tests := []struct {
|
|
name string
|
|
arg any
|
|
exp string
|
|
params bool
|
|
isApier bool
|
|
}{
|
|
{
|
|
name: "nil argument",
|
|
arg: nil,
|
|
params: false,
|
|
isApier: false,
|
|
},
|
|
{
|
|
name: "check error missing param",
|
|
arg: "test",
|
|
exp: "jsonrpc: request body missing params",
|
|
params: true,
|
|
isApier: false,
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
conn := &bufferClose{
|
|
Buffer: &bytes.Buffer{},
|
|
}
|
|
s := NewCustomJSONServerCodec(conn)
|
|
sj := s.(*jsonServerCodec)
|
|
|
|
if !tt.params {
|
|
jm, _ := json.RawMessage.MarshalJSON([]byte(`{
|
|
"method": "ApierV.Method",
|
|
"params": [{
|
|
"TPid": "test"
|
|
}],
|
|
"id": 0
|
|
}`))
|
|
js := json.RawMessage(jm)
|
|
sj.req.Params = &js
|
|
}
|
|
if tt.isApier {
|
|
sj.req.isApier = true
|
|
}
|
|
|
|
rcv := s.ReadRequestBody(tt.arg)
|
|
|
|
if rcv != nil {
|
|
if rcv.Error() != tt.exp {
|
|
t.Errorf("recived %s, expected %s", rcv, tt.exp)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestJSONReadRequestBody2(t *testing.T) {
|
|
conn := &bufferClose{
|
|
Buffer: &bytes.Buffer{},
|
|
}
|
|
s := NewCustomJSONServerCodec(conn)
|
|
sj := s.(*jsonServerCodec)
|
|
|
|
b, _ := json.Marshal([1]any{&CGREvent{Tenant: "cgrates.org"}})
|
|
js := json.RawMessage(b)
|
|
sj.req.Params = &js
|
|
|
|
sj.req.isApier = true
|
|
|
|
args := &MethodParameters{
|
|
Method: "test",
|
|
Parameters: [1]any{&CGREvent{Tenant: "cgrates.net"}},
|
|
}
|
|
rcv := s.ReadRequestBody(args)
|
|
|
|
if rcv != nil {
|
|
t.Errorf("recived %v, expected %v", rcv, nil)
|
|
}
|
|
|
|
a := args.Parameters
|
|
if a.(map[string]any)[Tenant] != "cgrates.org" {
|
|
t.Errorf("expected %s, recived %s", args.Parameters.(*CGREvent).Tenant, "cgrates.org")
|
|
}
|
|
}
|
|
|
|
func TestJSONReadRequestBody3(t *testing.T) {
|
|
conn := &bufferClose{
|
|
Buffer: &bytes.Buffer{},
|
|
}
|
|
s := NewCustomJSONServerCodec(conn)
|
|
sj := s.(*jsonServerCodec)
|
|
|
|
b, _ := json.Marshal([1]any{&CGREvent{Tenant: "cgrates.org"}})
|
|
js := json.RawMessage(b)
|
|
sj.req.Params = &js
|
|
|
|
sj.req.isApier = false
|
|
|
|
args := &MethodParameters{
|
|
Method: "test",
|
|
Parameters: [1]any{&CGREvent{Tenant: "cgrates.net"}},
|
|
}
|
|
rcv := s.ReadRequestBody(args)
|
|
|
|
if rcv != nil {
|
|
t.Errorf("recived %v, expected %v", rcv, nil)
|
|
}
|
|
|
|
a := args.Parameters.([1]any)
|
|
if a[0].(*CGREvent).Tenant != "cgrates.net" {
|
|
t.Errorf("expected %s, recived %s", a[0].(*CGREvent).Tenant, "cgrate.net")
|
|
}
|
|
}
|
|
|
|
/*
|
|
- NewCustomJSONServerCodec
|
|
- defer Close
|
|
- ReadRequestHeader
|
|
- check whether c.req was populated correctly
|
|
- check whether c.seq was incremented
|
|
- check whether c.req.Id was added to c.pending array
|
|
- ReadRequestBody
|
|
- check if x.Parameters was properly modified
|
|
- WriteResponse
|
|
- check if the rpc.Response is populated correctly
|
|
*/
|
|
func TestJSONCodecOK(t *testing.T) {
|
|
//Create server
|
|
conn := &bufferClose{
|
|
Buffer: &bytes.Buffer{},
|
|
}
|
|
s := NewCustomJSONServerCodec(conn)
|
|
c := s.(*jsonServerCodec)
|
|
|
|
defer s.Close()
|
|
|
|
//ReadRequesHeader
|
|
rr := rpc.Request{
|
|
ServiceMethod: "Service.Method",
|
|
Seq: 1,
|
|
}
|
|
|
|
conn.Write([]byte(`{
|
|
"method": "ApierV.Method",
|
|
"params": [{
|
|
"TPid": "test"
|
|
}],
|
|
"id": 0
|
|
}`))
|
|
|
|
err := s.ReadRequestHeader(&rr)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if c.req.Method != "ApierV.Method" {
|
|
t.Errorf("received %v, expected %v", c.req.Method, "ApierV.Method")
|
|
}
|
|
|
|
exp := json.RawMessage([]byte{48})
|
|
rcv := *c.pending[1]
|
|
if !reflect.DeepEqual(rcv, exp) {
|
|
t.Errorf("received %v, expected %v", rcv, exp)
|
|
}
|
|
|
|
if c.seq != 1 {
|
|
t.Errorf("received %v, expected %v", c.seq, 1)
|
|
}
|
|
|
|
//ReadRequestBody
|
|
b, _ := json.Marshal([1]any{&CGREvent{Tenant: "cgrates.org"}})
|
|
js := json.RawMessage(b)
|
|
c.req.Params = &js
|
|
|
|
c.req.isApier = true
|
|
|
|
args := &MethodParameters{
|
|
Method: "test",
|
|
Parameters: [1]any{&CGREvent{Tenant: "cgrates.net"}},
|
|
}
|
|
err = s.ReadRequestBody(args)
|
|
|
|
if err != nil {
|
|
t.Errorf("received %v, expected %v", err, nil)
|
|
}
|
|
|
|
a := args.Parameters
|
|
if a.(map[string]any)[Tenant] != "cgrates.org" {
|
|
t.Errorf("expected %s, received %s", args.Parameters.(*CGREvent).Tenant, "cgrates.org")
|
|
}
|
|
|
|
//WriteResponse
|
|
res := rpc.Response{
|
|
Seq: 1,
|
|
}
|
|
err = c.WriteResponse(&res, "test")
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
mp := make(map[string]any)
|
|
err = c.dec.Decode(&mp)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if mp["error"] != nil ||
|
|
mp["result"] != "test" ||
|
|
mp["id"] != 0. {
|
|
t.Error("unexpected reply", mp)
|
|
}
|
|
}
|
|
|
|
func TestJSONCodecWriteResponse(t *testing.T) {
|
|
conn := &bufferClose{
|
|
Buffer: &bytes.Buffer{},
|
|
}
|
|
s := NewCustomJSONServerCodec(conn)
|
|
c := s.(*jsonServerCodec)
|
|
|
|
defer s.Close()
|
|
|
|
res := rpc.Response{
|
|
Seq: 1,
|
|
}
|
|
err := c.WriteResponse(&res, "test")
|
|
if err.Error() != "invalid sequence number in response" {
|
|
t.Error(err)
|
|
}
|
|
}
|
|
|
|
func TestJSONCodecWriteResponse2(t *testing.T) {
|
|
conn := &bufferClose{
|
|
Buffer: &bytes.Buffer{},
|
|
}
|
|
s := NewCustomJSONServerCodec(conn)
|
|
c := s.(*jsonServerCodec)
|
|
|
|
conn.Write([]byte(`{
|
|
"method": "ApierV.Method",
|
|
"params": [{
|
|
"TPid": "test"
|
|
}]
|
|
}`))
|
|
|
|
defer s.Close()
|
|
|
|
rr := rpc.Request{
|
|
ServiceMethod: "Service.Method",
|
|
Seq: 1,
|
|
}
|
|
err := s.ReadRequestHeader(&rr)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
res := rpc.Response{
|
|
Seq: 1,
|
|
Error: "error",
|
|
}
|
|
err = c.WriteResponse(&res, "test")
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
mp := make(map[string]any)
|
|
err = c.dec.Decode(&mp)
|
|
if err != nil {
|
|
t.Error(err)
|
|
}
|
|
|
|
if mp["error"] != "error" ||
|
|
mp["result"] != nil ||
|
|
mp["id"] != nil {
|
|
t.Error("unexpected reply", mp)
|
|
}
|
|
}
|
|
|
|
func TestJSONCodecClose(t *testing.T) {
|
|
conn := &bufferClose{
|
|
Buffer: &bytes.Buffer{},
|
|
}
|
|
s := NewCustomJSONServerCodec(conn)
|
|
|
|
err := s.Close()
|
|
|
|
if err != nil {
|
|
t.Errorf("unexpected error: %s", err)
|
|
}
|
|
}
|