Adjust + Test

models/peer/peer_mongo_accessor.go

@@ -10,17 +10,18 @@ import (
 )
 
 type peerMongoAccessor struct {
-	utils.AbstractAccessor // AbstractAccessor contains the basic fields of an accessor (model, caller)
-	OverrideAuth           bool
+	utils.AbstractAccessor[*Peer] // AbstractAccessor contains the basic fields of an accessor (model, caller)
+	OverrideAuth                  bool
 }
 
 // New creates a new instance of the peerMongoAccessor
 func NewShallowAccessor() *peerMongoAccessor {
 	return &peerMongoAccessor{
 		OverrideAuth: true,
-		AbstractAccessor: utils.AbstractAccessor{
+		AbstractAccessor: utils.AbstractAccessor[*Peer]{
 			Logger: logs.CreateLogger(tools.PEER.String()), // Create a logger with the data type
 			Type:   tools.PEER,
+			New:    func() *Peer { return &Peer{} },
 		},
 	}
 }
@@ -28,10 +29,11 @@ func NewShallowAccessor() *peerMongoAccessor {
 func NewAccessor(request *tools.APIRequest) *peerMongoAccessor {
 	return &peerMongoAccessor{
 		OverrideAuth: false,
-		AbstractAccessor: utils.AbstractAccessor{
+		AbstractAccessor: utils.AbstractAccessor[*Peer]{
 			Logger:  logs.CreateLogger(tools.PEER.String()), // Create a logger with the data type
 			Request: request,
 			Type:    tools.PEER,
+			New:     func() *Peer { return &Peer{} },
 		},
 	}
 }
@@ -43,42 +45,7 @@ func (wfa *peerMongoAccessor) ShouldVerifyAuth() bool {
 /*
 * Nothing special here, just the basic CRUD operations
  */
-
-func (wfa *peerMongoAccessor) DeleteOne(id string) (utils.DBObject, int, error) {
-	return utils.GenericDeleteOne(id, wfa)
-}
-
-func (wfa *peerMongoAccessor) UpdateOne(set utils.DBObject, id string) (utils.DBObject, int, error) {
-	return utils.GenericUpdateOne(set.(*Peer), id, wfa, &Peer{})
-}
-
-func (wfa *peerMongoAccessor) StoreOne(data utils.DBObject) (utils.DBObject, int, error) {
-	return utils.GenericStoreOne(data.(*Peer), wfa)
-}
-
-func (wfa *peerMongoAccessor) CopyOne(data utils.DBObject) (utils.DBObject, int, error) {
-	return utils.GenericStoreOne(data, wfa)
-}
-
-func (dca *peerMongoAccessor) LoadOne(id string) (utils.DBObject, int, error) {
-	return utils.GenericLoadOne[*Peer](id, func(d utils.DBObject) (utils.DBObject, int, error) {
-		return d, 200, nil
-	}, dca)
-}
-
-func (wfa *peerMongoAccessor) LoadAll(isDraft bool) ([]utils.ShallowDBObject, int, error) {
-	return utils.GenericLoadAll[*Peer](func(d utils.DBObject) utils.ShallowDBObject {
-		return d
-	}, isDraft, wfa)
-}
-
-func (wfa *peerMongoAccessor) Search(filters *dbs.Filters, search string, isDraft bool) ([]utils.ShallowDBObject, int, error) {
-	return utils.GenericSearch[*Peer](filters, search, wfa.GetDefaultFilter(search),
-		func(d utils.DBObject) utils.ShallowDBObject {
-			return d
-		}, isDraft, wfa)
-}
-func (a *peerMongoAccessor) GetDefaultFilter(search string) *dbs.Filters {
+func (a *peerMongoAccessor) GetObjectFilters(search string) *dbs.Filters {
 	if i, err := strconv.Atoi(search); err == nil {
 		m := map[string][]dbs.Filter{ // search by name if no filters are provided
 			"relation": {{Operator: dbs.EQUAL.String(), Value: i}},

models/peer/tests/peer_cache_test.go

@@ -1,100 +0,0 @@
-package peer_test
-
-import (
-	"encoding/json"
-	"testing"
-
-	"cloud.o-forge.io/core/oc-lib/models/peer"
-	"cloud.o-forge.io/core/oc-lib/tools"
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-)
-
-// MockHTTPCaller mocks tools.HTTPCaller
-type MockHTTPCaller struct {
-	mock.Mock
-	URLS map[tools.DataType]map[tools.METHOD]string
-}
-
-func (c *MockHTTPCaller) GetUrls() map[tools.DataType]map[tools.METHOD]string {
-	return c.URLS
-}
-
-func (m *MockHTTPCaller) CallPost(url, token string, body interface{}, types ...string) ([]byte, error) {
-	args := m.Called(url, token, body)
-	return args.Get(0).([]byte), args.Error(1)
-}
-
-func (m *MockHTTPCaller) CallGet(url, token string, types ...string) ([]byte, error) {
-	args := m.Called(url, token)
-	return args.Get(0).([]byte), args.Error(1)
-}
-
-func (m *MockHTTPCaller) CallDelete(url, token string) ([]byte, error) {
-	args := m.Called(url, token)
-	return args.Get(0).([]byte), args.Error(1)
-}
-
-func TestLaunchPeerExecution_PeerNotReachable(t *testing.T) {
-	cache := &peer.PeerCache{}
-	caller := &MockHTTPCaller{
-		URLS: map[tools.DataType]map[tools.METHOD]string{
-			tools.PEER: {
-				tools.POST: "/execute/:id",
-			},
-		},
-	}
-	exec, err := cache.LaunchPeerExecution("peer-id", "data-id", tools.PEER, tools.POST, map[string]string{"a": "b"}, caller)
-	assert.Nil(t, exec)
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "not reachable")
-}
-
-func TestExecSuccess(t *testing.T) {
-	cache := &peer.PeerCache{}
-	caller := &MockHTTPCaller{}
-	url := "http://mockpeer/resource"
-	response := map[string]interface{}{"result": "ok"}
-	data, _ := json.Marshal(response)
-
-	caller.On("CallPost", url, "", mock.Anything).Return(data, nil)
-	_, err := cache.Exec(url, tools.POST, map[string]string{"key": "value"}, caller)
-	assert.NoError(t, err)
-	caller.AssertExpectations(t)
-}
-
-func TestExecReturnsErrorField(t *testing.T) {
-	cache := &peer.PeerCache{}
-	caller := &MockHTTPCaller{}
-	url := "http://mockpeer/resource"
-	response := map[string]interface{}{"error": "something failed"}
-	data, _ := json.Marshal(response)
-
-	caller.On("CallPost", url, "", mock.Anything).Return(data, nil)
-	_, err := cache.Exec(url, tools.POST, map[string]string{"key": "value"}, caller)
-	assert.Error(t, err)
-	assert.Equal(t, "something failed", err.Error())
-}
-
-func TestExecInvalidJSON(t *testing.T) {
-	cache := &peer.PeerCache{}
-	caller := &MockHTTPCaller{}
-	url := "http://mockpeer/resource"
-	caller.On("CallPost", url, "", mock.Anything).Return([]byte("{invalid json}"), nil)
-	_, err := cache.Exec(url, tools.POST, map[string]string{"key": "value"}, caller)
-	assert.Error(t, err)
-	assert.Contains(t, err.Error(), "invalid character")
-}
-
-type mockAccessor struct {
-	loadOne   func(string) (interface{}, int, error)
-	updateOne func(interface{}, string) error
-}
-
-func (m *mockAccessor) LoadOne(id string) (interface{}, int, error) {
-	return m.loadOne(id)
-}
-
-func (m *mockAccessor) UpdateOne(i interface{}, id string) error {
-	return m.updateOne(i, id)
-}

models/peer/tests/peer_test.go

@@ -3,127 +3,107 @@ package peer_test
 import (
 	"testing"
 
-	"github.com/stretchr/testify/assert"
-	"github.com/stretchr/testify/mock"
-
-	"cloud.o-forge.io/core/oc-lib/dbs"
 	"cloud.o-forge.io/core/oc-lib/models/peer"
-	"cloud.o-forge.io/core/oc-lib/models/utils"
+	"cloud.o-forge.io/core/oc-lib/tools"
+	"github.com/stretchr/testify/assert"
 )
 
-type MockAccessor struct {
-	mock.Mock
-	utils.AbstractAccessor
+// ---- PeerRelation ----
+
+func TestPeerRelation_String(t *testing.T) {
+	assert.Equal(t, "UNKNOWN", peer.NONE.String())
+	assert.Equal(t, "SELF", peer.SELF.String())
+	assert.Equal(t, "PARTNER", peer.PARTNER.String())
+	assert.Equal(t, "BLACKLIST", peer.BLACKLIST.String())
 }
 
-func (m *MockAccessor) DeleteOne(id string) (utils.DBObject, int, error) {
-	args := m.Called(id)
-	return args.Get(0).(utils.DBObject), args.Int(1), args.Error(2)
+func TestPeerRelation_Path(t *testing.T) {
+	assert.Equal(t, "unknown", peer.NONE.Path())
+	assert.Equal(t, "self", peer.SELF.Path())
+	assert.Equal(t, "partner", peer.PARTNER.Path())
+	assert.Equal(t, "blacklist", peer.BLACKLIST.Path())
 }
 
-func (m *MockAccessor) UpdateOne(set utils.DBObject, id string) (utils.DBObject, int, error) {
-	args := m.Called(set, id)
-	return args.Get(0).(utils.DBObject), args.Int(1), args.Error(2)
+func TestPeerRelation_EnumIndex(t *testing.T) {
+	assert.Equal(t, 0, peer.NONE.EnumIndex())
+	assert.Equal(t, 1, peer.SELF.EnumIndex())
+	assert.Equal(t, 2, peer.PARTNER.EnumIndex())
+	assert.Equal(t, 3, peer.BLACKLIST.EnumIndex())
+	assert.Equal(t, 4, peer.PENDING_PARTNER.EnumIndex())
 }
 
-func (m *MockAccessor) StoreOne(data utils.DBObject) (utils.DBObject, int, error) {
-	args := m.Called(data)
-	return args.Get(0).(utils.DBObject), args.Int(1), args.Error(2)
+func TestGetRelationPath(t *testing.T) {
+	assert.Equal(t, 1, peer.GetRelationPath("self"))
+	assert.Equal(t, 2, peer.GetRelationPath("partner"))
+	assert.Equal(t, 3, peer.GetRelationPath("blacklist"))
+	assert.Equal(t, -1, peer.GetRelationPath("nonexistent"))
 }
 
-func (m *MockAccessor) LoadOne(id string) (utils.DBObject, int, error) {
-	args := m.Called(id)
-	return args.Get(0).(utils.DBObject), args.Int(1), args.Error(2)
+// ---- Peer model ----
+
+func TestPeer_VerifyAuth(t *testing.T) {
+	p := &peer.Peer{}
+	assert.True(t, p.VerifyAuth("get", nil))
+	assert.True(t, p.VerifyAuth("delete", &tools.APIRequest{}))
 }
 
-func (m *MockAccessor) LoadAll(isDraft bool) ([]utils.ShallowDBObject, int, error) {
-	args := m.Called(isDraft)
-	return args.Get(0).([]utils.ShallowDBObject), args.Int(1), args.Error(2)
+func TestPeer_CanDelete(t *testing.T) {
+	p := &peer.Peer{}
+	assert.False(t, p.CanDelete())
 }
 
-func (m *MockAccessor) Search(filters *dbs.Filters, search string, isDraft bool) ([]utils.ShallowDBObject, int, error) {
-	args := m.Called(filters, search, isDraft)
-	return args.Get(0).([]utils.ShallowDBObject), args.Int(1), args.Error(2)
+func TestPeer_GetAccessor(t *testing.T) {
+	p := &peer.Peer{}
+	req := &tools.APIRequest{}
+	acc := p.GetAccessor(req)
+	assert.NotNil(t, acc)
 }
 
-func newTestPeer() *peer.Peer {
-	return &peer.Peer{
-		NATSAddress:   "",
-		StreamAddress: "127.0.0.1",
-		APIUrl:        "http://localhost",
-		WalletAddress: "0x123",
-		PublicKey:     "pubkey",
-		Relation:      peer.SELF,
-	}
+func TestPeer_AddExecution_Deduplication(t *testing.T) {
+	p := &peer.Peer{}
+	exec := peer.PeerExecution{Method: "POST", Url: "http://peer/data", Body: "body1"}
+
+	p.AddExecution(exec)
+	assert.Len(t, p.FailedExecution, 1)
+
+	// Second add of same execution should not duplicate
+	p.AddExecution(exec)
+	assert.Len(t, p.FailedExecution, 1)
+
+	// Different execution should be added
+	exec2 := peer.PeerExecution{Method: "GET", Url: "http://peer/data", Body: nil}
+	p.AddExecution(exec2)
+	assert.Len(t, p.FailedExecution, 2)
 }
 
-func TestDeleteOne_UsingMock(t *testing.T) {
-	mockAcc := new(MockAccessor)
-	mockAcc.On("DeleteOne", "id").Return(newTestPeer(), 200, nil)
+func TestPeer_RemoveExecution(t *testing.T) {
+	p := &peer.Peer{}
+	exec1 := peer.PeerExecution{Method: "POST", Url: "http://peer/a", Body: nil}
+	exec2 := peer.PeerExecution{Method: "DELETE", Url: "http://peer/b", Body: nil}
 
-	obj, code, err := mockAcc.DeleteOne("id")
-	assert.NoError(t, err)
-	assert.Equal(t, 200, code)
-	assert.NotNil(t, obj)
-	mockAcc.AssertExpectations(t)
+	p.AddExecution(exec1)
+	p.AddExecution(exec2)
+	assert.Len(t, p.FailedExecution, 2)
+
+	p.RemoveExecution(exec1)
+	assert.Len(t, p.FailedExecution, 1)
+	assert.Equal(t, exec2, p.FailedExecution[0])
 }
 
-func TestUpdateOne_UsingMock(t *testing.T) {
-	mockAcc := new(MockAccessor)
-	peerObj := newTestPeer()
-	mockAcc.On("UpdateOne", peerObj, "id").Return(peerObj, 200, nil)
+func TestPeer_RemoveExecution_NotFound(t *testing.T) {
+	p := &peer.Peer{}
+	exec := peer.PeerExecution{Method: "POST", Url: "http://peer/x", Body: nil}
+	p.AddExecution(exec)
 
-	obj, code, err := mockAcc.UpdateOne(peerObj, "id")
-	assert.NoError(t, err)
-	assert.Equal(t, 200, code)
-	assert.Equal(t, peerObj, obj)
-	mockAcc.AssertExpectations(t)
+	other := peer.PeerExecution{Method: "DELETE", Url: "http://other/x", Body: nil}
+	p.RemoveExecution(other)
+	assert.Len(t, p.FailedExecution, 1) // unchanged
 }
 
-func TestStoreOne_UsingMock(t *testing.T) {
-	mockAcc := new(MockAccessor)
-	peerObj := newTestPeer()
-	mockAcc.On("StoreOne", peerObj).Return(peerObj, 200, nil)
-
-	obj, code, err := mockAcc.StoreOne(peerObj)
-	assert.NoError(t, err)
-	assert.Equal(t, 200, code)
-	assert.Equal(t, peerObj, obj)
-	mockAcc.AssertExpectations(t)
-}
-
-func TestLoadOne_UsingMock(t *testing.T) {
-	mockAcc := new(MockAccessor)
-	mockAcc.On("LoadOne", "test-id").Return(newTestPeer(), 200, nil)
-
-	obj, code, err := mockAcc.LoadOne("test-id")
-	assert.NoError(t, err)
-	assert.Equal(t, 200, code)
-	assert.NotNil(t, obj)
-	mockAcc.AssertExpectations(t)
-}
-
-func TestLoadAll_UsingMock(t *testing.T) {
-	mockAcc := new(MockAccessor)
-	expected := []utils.ShallowDBObject{newTestPeer()}
-	mockAcc.On("LoadAll", false).Return(expected, 200, nil)
-
-	objs, code, err := mockAcc.LoadAll(false)
-	assert.NoError(t, err)
-	assert.Equal(t, 200, code)
-	assert.Equal(t, expected, objs)
-	mockAcc.AssertExpectations(t)
-}
-
-func TestSearch_UsingMock(t *testing.T) {
-	mockAcc := new(MockAccessor)
-	filters := &dbs.Filters{}
-	expected := []utils.ShallowDBObject{newTestPeer()}
-	mockAcc.On("Search", filters, "test", false).Return(expected, 200, nil)
-
-	objs, code, err := mockAcc.Search(filters, "test", false)
-	assert.NoError(t, err)
-	assert.Equal(t, 200, code)
-	assert.Equal(t, expected, objs)
-	mockAcc.AssertExpectations(t)
+func TestPeer_RemoveExecution_Empty(t *testing.T) {
+	p := &peer.Peer{}
+	// Should not panic on empty list
+	exec := peer.PeerExecution{Method: "GET", Url: "http://peer/x", Body: nil}
+	p.RemoveExecution(exec)
+	assert.Empty(t, p.FailedExecution)
 }