X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=a1-go%2Fpkg%2Fresthooks%2Fresthooks_test.go;h=4466927cf50695fa4c55951fad20938d94a3955b;hb=1a41ce75dbf508ae4d85c2dc4a562f36da04bb65;hp=cef23ea4cabf908c1cfa7198b65ceae4b5f802db;hpb=3ad6de4df1dfe70e467064e6477f2e6068e87048;p=ric-plt%2Fa1.git diff --git a/a1-go/pkg/resthooks/resthooks_test.go b/a1-go/pkg/resthooks/resthooks_test.go index cef23ea..4466927 100644 --- a/a1-go/pkg/resthooks/resthooks_test.go +++ b/a1-go/pkg/resthooks/resthooks_test.go @@ -25,6 +25,7 @@ import ( "os" "strconv" "testing" + "time" "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/a1" "gerrit.o-ran-sc.org/r/ric-plt/a1/pkg/models" @@ -32,20 +33,27 @@ import ( "github.com/stretchr/testify/mock" ) +type RmrSenderMock struct { + mock.Mock +} + var rh *Resthook var sdlInst *SdlMock +var rmrSenderInst *RmrSenderMock func TestMain(m *testing.M) { sdlInst = new(SdlMock) sdlInst.On("GetAll", "A1m_ns").Return([]string{"a1.policy_instance.1006001.qos", + "a1.policy_instance.20005.123456", + "a1.policy_instance.20005.234567", "a1.policy_type.1006001", "a1.policy_type.20000", "a1.policy_inst_metadata.1006001.qos", }, nil) - + RMRclient = new(RMRClientMock) a1.Init() - rh = createResthook(sdlInst) + rh = createResthook(sdlInst, RMRclient) code := m.Run() os.Exit(code) } @@ -59,8 +67,6 @@ func TestGetPolicyType(t *testing.T) { policyTypeId := models.PolicyTypeID(20001) - resp := rh.GetPolicyType(policyTypeId) - var policyTypeSchema models.PolicyTypeSchema name := "admission_control_policy_mine" policyTypeSchema.Name = &name @@ -72,10 +78,11 @@ func TestGetPolicyType(t *testing.T) { "blocking_rate": {"type":"number","default":10,"minimum":1,"maximum":100,"description": "% Connections to block",},"additionalProperties": false,},}` policyTypeSchema.CreateSchema = schema key := a1PolicyPrefix + strconv.FormatInt((int64(policyTypeId)), 10) - + var keys [1]string + keys[0] = key //Setup Expectations - sdlInst.On("Get", a1MediatorNs, policyTypeId).Return(map[string]interface{}{key: policyTypeSchema}, nil) - + sdlInst.On("Get", a1MediatorNs, keys[:]).Return(map[string]interface{}{key: policyTypeSchema}, nil) + resp := rh.GetPolicyType(policyTypeId) assert.NotNil(t, resp) sdlInst.AssertExpectations(t) @@ -111,6 +118,42 @@ func TestCreatePolicyType(t *testing.T) { } func TestCreatePolicyTypeInstance(t *testing.T) { + var policyInstanceID models.PolicyInstanceID + policyInstanceID = "123456" + var httpBody = `{"enforce":true,"window_length":20,"blocking_rate":20,"trigger_threshold":10}` + instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID) + var policyTypeId models.PolicyTypeID + policyTypeId = 20001 + + var instancedata map[string]interface{} + + json.Unmarshal([]byte(httpBody), &instancedata) + + data, _ := json.Marshal(instancedata) + a1.Logger.Debug("Marshaled data : %+v", string(data)) + a1.Logger.Debug("instancekey : %+v", instancekey) + instancearr := []interface{}{instancekey, string(data)} + sdlInst.On("Set", "A1m_ns", instancearr).Return(nil) + + metadatainstancekey := a1InstanceMetadataPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID) + creation_timestamp := time.Now() + var metadatajson []interface{} + metadatajson = append(metadatajson, map[string]string{"created_at": creation_timestamp.Format("2006-01-02 15:04:05"), "has_been_deleted": "False"}) + metadata, _ := json.Marshal(metadatajson) + a1.Logger.Debug("Marshaled Metadata : %+v", string(metadata)) + a1.Logger.Debug("metadatainstancekey : %+v", metadatainstancekey) + metadatainstancearr := []interface{}{metadatainstancekey, string(metadata)} + sdlInst.On("Set", "A1m_ns", metadatainstancearr).Return(nil) + rmrSenderInst.On("RmrSendToXapp", "httpBodyString").Return(true) + + errresp := rh.CreatePolicyInstance(policyTypeId, policyInstanceID, instancedata) + + assert.Nil(t, errresp) + sdlInst.AssertExpectations(t) +} + +func TestGetPolicyInstance(t *testing.T) { + var policyTypeId models.PolicyTypeID policyTypeId = 20001 var policyInstanceID models.PolicyInstanceID @@ -121,19 +164,29 @@ func TestCreatePolicyTypeInstance(t *testing.T) { "blocking_rate":20, "trigger_threshold":10 }` - instancekey := a1PolicyPrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID) - data, _ := json.Marshal(httpBody) - a1.Logger.Debug("Marshaled String : %+v", string(data)) + instancekey := a1InstancePrefix + strconv.FormatInt(20001, 10) + "." + string(policyInstanceID) + a1.Logger.Debug("httpBody String : %+v", httpBody) a1.Logger.Debug("key : %+v", instancekey) + var keys [1]string + keys[0] = instancekey + //Setup Expectations + sdlInst.On("Get", a1MediatorNs, keys[:]).Return(httpBody, nil) - instancearr := []interface{}{instancekey, string(data)} - sdlInst.On("Set", "A1m_ns", instancearr).Return("CREATE", nil) - errresp := rh.CreatePolicyInstance(policyTypeId, policyInstanceID, httpBody) + resp, err := rh.GetPolicyInstance(policyTypeId, policyInstanceID) + a1.Logger.Error("err : %+v", err) + assert.NotNil(t, resp) - assert.Nil(t, errresp) sdlInst.AssertExpectations(t) } +func TestGetAllPolicyIntances(t *testing.T) { + var policyTypeId models.PolicyTypeID + policyTypeId = 20005 + resp, err := rh.GetAllPolicyInstance(policyTypeId) + a1.Logger.Error("err : %+v", err) + assert.Equal(t, 2, len(resp)) +} + type SdlMock struct { mock.Mock } @@ -148,20 +201,29 @@ func (s *SdlMock) Get(ns string, keys []string) (map[string]interface{}, error) args := s.MethodCalled("Get", ns, keys) a1.Logger.Debug("keys :%+v", args.Get(1)) policytypeid := int64(20001) + policyInstanceID := "123456" + var policySchemaString string + var key string + if keys[0] == "a1.policy_instance.20001.123456" { + policySchemaString = `{ + "enforce":true, + "window_length":20, + "blocking_rate":20, + "trigger_threshold":10 + }` + key = a1InstancePrefix + strconv.FormatInt(policytypeid, 10) + "." + string(policyInstanceID) + } else if keys[0] == "a1.policy_type.20001" { + policySchemaString = `{"create_schema":{"$schema":"http://json-schema.org/draft-07/schema#","properties":{"additionalProperties":false,"blocking_rate":{"default":10,"description":"% Connections to block","maximum":1001,"minimum":1,"type":"number"},"enforce":{"default":"true","type":"boolean"},"window_length":{"default":1,"description":"Sliding window length (in minutes)","maximum":60,"minimum":1,"type":"integer"}},"type":"object"},"description":"various parameters to control admission of dual connection","name":"admission_control_policy_mine","policy_type_id":20001}` + key = a1PolicyPrefix + strconv.FormatInt((policytypeid), 10) + } + a1.Logger.Debug(" policy SchemaString %+v", policySchemaString) + policyTypeSchema, _ := json.Marshal((policySchemaString)) + a1.Logger.Debug(" policyTypeSchema %+v", string(policyTypeSchema)) + + a1.Logger.Debug(" key for policy type %+v", key) + mp := map[string]interface{}{key: string(policySchemaString)} + a1.Logger.Debug("Get Called and mp return %+v ", mp) - policyTypeSchemaString := `{"name":"admission_control_policy_mine","description":"various parameters to control admission of dual connection","policy_type_id": 20001,"create_schema":{"$schema": "http://json-schema.org/draft-07/schema#","type": "object","properties": {"enforce": {"type": "boolean","default": "true"},"window_length": {"type":"integer","default": 1,"minimum": 1,"maximum": 60,"description": "Sliding window length (in minutes)"},"blocking_rate": {"type": "number","default": 10,"minimum": 1,"maximum": 1001,"description": "% Connections to block"},"additionalProperties": false}}}` - - a1.Logger.Error(" policyTypeSchemaString %+v", policyTypeSchemaString) - policyTypeSchema, _ := json.Marshal((policyTypeSchemaString)) - // a1.Logger.Error(" policyTypeSchema error %+v", err) - a1.Logger.Error(" policyTypeSchema %+v", string(policyTypeSchema)) - var p models.PolicyTypeSchema - _ = json.Unmarshal([]byte(string(policyTypeSchemaString)), &p) - a1.Logger.Error("unmarshalled policyTypeSchema %+v", p.CreateSchema) - key := a1PolicyPrefix + strconv.FormatInt((policytypeid), 10) - a1.Logger.Error(" key for policy type %+v", key) - mp := map[string]interface{}{key: string(policyTypeSchema)} - a1.Logger.Error("Get Called and mp return %+v ", mp) return mp, nil } @@ -172,9 +234,14 @@ func (s *SdlMock) SetIfNotExists(ns string, key string, data interface{}) (bool, func (s *SdlMock) Set(ns string, pairs ...interface{}) error { args := s.MethodCalled("Set", ns, pairs) - return args.Error(1) + return args.Error(0) } func (s *SdlMock) SetIf(ns string, key string, oldData, newData interface{}) (bool, error) { args := s.MethodCalled("SetIfNotExists", ns, key, oldData, newData) return args.Bool(0), args.Error(1) } + +func (rmr *RmrSenderMock) RmrSendToXapp(httpBodyString string) bool { + args := rmr.MethodCalled("RmrSendToXapp", httpBodyString) + return args.Bool(0) +}