draft test

models/utils/tests/abstracts_test.go

@@ -0,0 +1,128 @@
+package models_test
+
+import (
+	"testing"
+	"time"
+
+	"cloud.o-forge.io/core/oc-lib/dbs"
+	"cloud.o-forge.io/core/oc-lib/models/utils"
+	"cloud.o-forge.io/core/oc-lib/tools"
+	"github.com/google/uuid"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestGenerateID(t *testing.T) {
+	ao := &utils.AbstractObject{}
+	ao.GenerateID()
+	assert.NotEmpty(t, ao.UUID)
+	_, err := uuid.Parse(ao.UUID)
+	assert.NoError(t, err)
+}
+
+func TestStoreDraftDefault(t *testing.T) {
+	ao := &utils.AbstractObject{IsDraft: true}
+	ao.StoreDraftDefault()
+	assert.False(t, ao.IsDraft)
+}
+
+func TestCanUpdate(t *testing.T) {
+	ao := &utils.AbstractObject{}
+	res, set := ao.CanUpdate(nil)
+	assert.True(t, res)
+	assert.Nil(t, set)
+}
+
+func TestCanDelete(t *testing.T) {
+	ao := &utils.AbstractObject{}
+	assert.True(t, ao.CanDelete())
+}
+
+func TestIsDrafted(t *testing.T) {
+	ao := &utils.AbstractObject{IsDraft: true}
+	assert.True(t, ao.IsDrafted())
+}
+
+func TestGetID(t *testing.T) {
+	u := uuid.New().String()
+	ao := &utils.AbstractObject{UUID: u}
+	assert.Equal(t, u, ao.GetID())
+}
+
+func TestGetName(t *testing.T) {
+	name := "MyObject"
+	ao := &utils.AbstractObject{Name: name}
+	assert.Equal(t, name, ao.GetName())
+}
+
+func TestGetCreatorID(t *testing.T) {
+	id := "creator-123"
+	ao := &utils.AbstractObject{CreatorID: id}
+	assert.Equal(t, id, ao.GetCreatorID())
+}
+
+func TestUpToDate_CreateFalse(t *testing.T) {
+	ao := &utils.AbstractObject{}
+	now := time.Now()
+	time.Sleep(time.Millisecond) // ensure time difference
+	ao.UpToDate("user123", "peer456", false)
+	assert.WithinDuration(t, now, ao.UpdateDate, time.Second)
+	assert.Equal(t, "peer456", ao.UpdaterID)
+	assert.Equal(t, "user123", ao.UserUpdaterID)
+	assert.True(t, ao.CreationDate.IsZero())
+}
+
+func TestUpToDate_CreateTrue(t *testing.T) {
+	ao := &utils.AbstractObject{}
+	now := time.Now()
+	time.Sleep(time.Millisecond)
+	ao.UpToDate("user123", "peer456", true)
+	assert.WithinDuration(t, now, ao.UpdateDate, time.Second)
+	assert.WithinDuration(t, now, ao.CreationDate, time.Second)
+	assert.Equal(t, "peer456", ao.UpdaterID)
+	assert.Equal(t, "peer456", ao.CreatorID)
+	assert.Equal(t, "user123", ao.UserUpdaterID)
+	assert.Equal(t, "user123", ao.UserCreatorID)
+}
+
+func TestVerifyAuth(t *testing.T) {
+	request := &tools.APIRequest{PeerID: "peer123"}
+	ao := &utils.AbstractObject{CreatorID: "peer123"}
+	assert.True(t, ao.VerifyAuth(request))
+
+	ao = &utils.AbstractObject{AccessMode: utils.Public}
+	assert.True(t, ao.VerifyAuth(nil))
+
+	ao = &utils.AbstractObject{AccessMode: utils.Private, CreatorID: "peer123"}
+	request = &tools.APIRequest{PeerID: "wrong"}
+	assert.False(t, ao.VerifyAuth(request))
+}
+
+func TestGetObjectFilters(t *testing.T) {
+	ao := &utils.AbstractObject{}
+	f := ao.GetObjectFilters("*")
+	assert.NotNil(t, f)
+	assert.Contains(t, f.Or, "abstractobject.name")
+	assert.Equal(t, dbs.LIKE.String(), f.Or["abstractobject.name"][0].Operator)
+}
+
+func TestDeserialize(t *testing.T) {
+	ao := &utils.AbstractObject{}
+	input := map[string]interface{}{"name": "test", "id": uuid.New().String()}
+	res := ao.Deserialize(input, &utils.AbstractObject{})
+	assert.NotNil(t, res)
+}
+
+func TestSerialize(t *testing.T) {
+	ao := &utils.AbstractObject{Name: "test", UUID: uuid.New().String()}
+	m := ao.Serialize(ao)
+	assert.Equal(t, "test", m["name"])
+}
+
+func TestAbstractAccessorMethods(t *testing.T) {
+	r := &utils.AbstractAccessor{Request: &tools.APIRequest{Username: "alice", PeerID: "peer1", Groups: []string{"dev"}}}
+	assert.True(t, r.ShouldVerifyAuth())
+	assert.Equal(t, "alice", r.GetUser())
+	assert.Equal(t, "peer1", r.GetPeerID())
+	assert.Equal(t, []string{"dev"}, r.GetGroups())
+	assert.Equal(t, r.Request.Caller, r.GetCaller())
+}

models/utils/tests/common_test.go

@@ -0,0 +1,168 @@
+package models_test
+
+import (
+	"errors"
+	"testing"
+
+	"cloud.o-forge.io/core/oc-lib/dbs"
+	"cloud.o-forge.io/core/oc-lib/models/utils"
+	"cloud.o-forge.io/core/oc-lib/tools"
+	"github.com/rs/zerolog"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+)
+
+// --- Mock Definitions ---
+
+type MockDBObject struct {
+	mock.Mock
+}
+
+func (m *MockAccessor) GetLogger() *zerolog.Logger {
+	return nil
+}
+func (m *MockAccessor) GetGroups() []string {
+	return []string{}
+}
+
+func (m *MockAccessor) GetCaller() *tools.HTTPCaller {
+	return nil
+}
+
+func (m *MockDBObject) GenerateID()        { m.Called() }
+func (m *MockDBObject) StoreDraftDefault() { m.Called() }
+func (m *MockDBObject) UpToDate(user, peer string, create bool) {
+	m.Called(user, peer, create)
+}
+func (m *MockDBObject) VerifyAuth(req *tools.APIRequest) bool {
+	args := m.Called(req)
+	return args.Bool(0)
+}
+func (m *MockDBObject) CanDelete() bool {
+	args := m.Called()
+	return args.Bool(0)
+}
+func (m *MockDBObject) CanUpdate(set utils.DBObject) (bool, utils.DBObject) {
+	args := m.Called(set)
+	return args.Bool(0), args.Get(1).(utils.DBObject)
+}
+func (m *MockDBObject) IsDrafted() bool {
+	args := m.Called()
+	return args.Bool(0)
+}
+func (m *MockDBObject) Serialize(obj utils.DBObject) map[string]interface{} {
+	args := m.Called(obj)
+	return args.Get(0).(map[string]interface{})
+}
+func (m *MockDBObject) Deserialize(mdata map[string]interface{}, obj utils.DBObject) utils.DBObject {
+	args := m.Called(mdata, obj)
+	return args.Get(0).(utils.DBObject)
+}
+func (m *MockDBObject) GetID() string {
+	args := m.Called()
+	return args.String(0)
+}
+func (m *MockDBObject) GetName() string {
+	args := m.Called()
+	return args.String(0)
+}
+
+type MockAccessor struct {
+	mock.Mock
+}
+
+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 (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)
+}
+
+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 (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 (m *MockAccessor) CopyOne(data utils.DBObject) (utils.DBObject, int, error) {
+	args := m.Called(data)
+	return args.Get(0).(utils.DBObject), args.Int(1), args.Error(2)
+}
+
+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 (m *MockAccessor) ShouldVerifyAuth() bool {
+	args := m.Called()
+	return args.Bool(0)
+}
+func (m *MockAccessor) GetRequest() *tools.APIRequest {
+	args := m.Called()
+	return args.Get(0).(*tools.APIRequest)
+}
+func (m *MockAccessor) GetType() tools.DataType {
+	args := m.Called()
+	return args.Get(0).(tools.DataType)
+}
+func (m *MockAccessor) Search(filters *dbs.Filters, s string, d bool) ([]utils.ShallowDBObject, int, error) {
+	args := m.Called(filters, s, d)
+	return args.Get(0).([]utils.ShallowDBObject), args.Int(1), args.Error(2)
+}
+
+func (m *MockAccessor) GetUser() string {
+	args := m.Called()
+	return args.String(0)
+}
+func (m *MockAccessor) GetPeerID() string {
+	args := m.Called()
+	return args.String(0)
+}
+
+// --- Test Cases ---
+
+func TestVerifyAccess_Authorized(t *testing.T) {
+	mockObj := new(MockDBObject)
+	mockAcc := new(MockAccessor)
+
+	req := &tools.APIRequest{PeerID: "peer"}
+	mockAcc.On("LoadOne", "123").Return(mockObj, 200, nil)
+	mockAcc.On("ShouldVerifyAuth").Return(true)
+	mockObj.On("VerifyAuth", req).Return(true)
+	mockAcc.On("GetRequest").Return(req)
+
+	err := utils.VerifyAccess(mockAcc, "123")
+	assert.NoError(t, err)
+}
+
+func TestVerifyAccess_Unauthorized(t *testing.T) {
+	mockObj := new(MockDBObject)
+	mockAcc := new(MockAccessor)
+
+	req := &tools.APIRequest{PeerID: "peer"}
+	mockAcc.On("LoadOne", "123").Return(mockObj, 200, nil)
+	mockAcc.On("ShouldVerifyAuth").Return(true)
+	mockObj.On("VerifyAuth", req).Return(false)
+	mockAcc.On("GetRequest").Return(req)
+
+	err := utils.VerifyAccess(mockAcc, "123")
+	assert.Error(t, err)
+	assert.Contains(t, err.Error(), "not allowed")
+}
+
+func TestVerifyAccess_LoadError(t *testing.T) {
+	mockAcc := new(MockAccessor)
+
+	mockAcc.On("LoadOne", "bad-id").Return(nil, 404, errors.New("not found"))
+
+	err := utils.VerifyAccess(mockAcc, "bad-id")
+	assert.Error(t, err)
+	assert.Equal(t, "not found", err.Error())
+}