Adding unit test cases for init.go and convert.go of AMF

internal/util/convert_test.go

@@ -0,0 +1,167 @@
+ package util
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"github.com/free5gc/openapi/models"
+)
+
+func TestSnssaiHexToModels(t *testing.T) {
+	t.Run("valid hex string with SST and SD", func(t *testing.T) {
+		hexStr := "01112233" // SST = 0x01 (1), SD = "112233"
+		expected := &models.Snssai{
+			Sst: 1,
+			Sd:  "112233",
+		}
+
+		snssai, err := SnssaiHexToModels(hexStr)
+		require.NoError(t, err)
+		assert.Equal(t, expected, snssai)
+	})
+
+	t.Run("invalid hex string for SST", func(t *testing.T) {
+		hexStr := "ZZ112233" // invalid SST hex
+
+		snssai, err := SnssaiHexToModels(hexStr)
+		assert.Nil(t, snssai)
+		assert.Error(t, err)
+	})
+}
+func TestSnssaiModelsToHex(t *testing.T) {
+	t.Run("valid Snssai with Sst and Sd", func(t *testing.T) {
+		snssai := models.Snssai{
+			Sst: 1,
+			Sd:  "112233",
+		}
+		expected := "01112233" // 01 (hex of 1) + Sd
+
+		hexStr := SnssaiModelsToHex(snssai)
+		assert.Equal(t, expected, hexStr)
+	})
+
+	t.Run("Sst with double digit value", func(t *testing.T) {
+		snssai := models.Snssai{
+			Sst: 26,
+			Sd:  "abcdef",
+		}
+		expected := "1aabcdef" // 1a is hex of 26
+
+		hexStr := SnssaiModelsToHex(snssai)
+		assert.Equal(t, expected, hexStr)
+	})
+
+	t.Run("empty Sd field", func(t *testing.T) {
+		snssai := models.Snssai{
+			Sst: 15,
+			Sd:  "",
+		}
+		expected := "0f" // just the hex of 15
+
+		hexStr := SnssaiModelsToHex(snssai)
+		assert.Equal(t, expected, hexStr)
+	})
+}
+func TestSeperateAmfId(t *testing.T) {
+	t.Run("valid AMF ID", func(t *testing.T) {
+		amfid := "12a1b2" // regionId = "12", rest = a1b2
+
+		regionId, setId, ptrId, err := SeperateAmfId(amfid)
+
+		assert.NoError(t, err)
+		assert.Equal(t, "12", regionId)
+		assert.Equal(t, "286", setId) // derived from bits
+		assert.Equal(t, "32", ptrId)  // derived from bits
+	})
+
+	t.Run("invalid AMF ID length", func(t *testing.T) {
+		amfid := "1234"
+
+		regionId, setId, ptrId, err := SeperateAmfId(amfid)
+
+		assert.Error(t, err)
+		assert.Empty(t, regionId)
+		assert.Empty(t, setId)
+		assert.Empty(t, ptrId)
+	})
+
+	t.Run("invalid AMF ID hex characters", func(t *testing.T) {
+		amfid := "12zzzz" // invalid hex in last 4 characters
+
+		regionId, setId, ptrId, err := SeperateAmfId(amfid)
+
+		assert.Error(t, err)
+		assert.Equal(t, "12", regionId)
+		assert.Empty(t, setId)
+		assert.Empty(t, ptrId)
+	})
+}
+
+func TestPlmnIdStringToModels(t *testing.T) {
+	t.Run("valid 5-digit PLMN ID", func(t *testing.T) {
+		plmnStr := "28393" // MCC: 310, MNC: 15
+
+		expected := models.PlmnId{
+			Mcc: "283",
+			Mnc: "93",
+		}
+
+		result := PlmnIdStringToModels(plmnStr)
+
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("valid 6-digit PLMN ID", func(t *testing.T) {
+		plmnStr := "460011" // MCC: 460, MNC: 011
+
+		expected := models.PlmnId{
+			Mcc: "460",
+			Mnc: "011",
+		}
+
+		result := PlmnIdStringToModels(plmnStr)
+
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("invalid PLMN ID (too short)", func(t *testing.T) {
+		plmnStr := "12" // invalid
+
+		defer func() {
+			if r := recover(); r == nil {
+				t.Error("Expected panic due to short plmnId, but function did not panic")
+			}
+		}()
+
+		_ = PlmnIdStringToModels(plmnStr) // should panic on plmnId[:3]
+	})
+}
+func TestTACConfigToModels(t *testing.T) {
+	t.Run("valid TAC integer string", func(t *testing.T) {
+		input := "12345"
+		expected := "003039" // 12345 in hex is 0x3039
+
+		result := TACConfigToModels(input)
+
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("maximum 3-byte TAC value", func(t *testing.T) {
+		input := "16777215" // 0xFFFFFF
+		expected := "ffffff"
+
+		result := TACConfigToModels(input)
+
+		assert.Equal(t, expected, result)
+	})
+
+	t.Run("invalid TAC string (non-numeric)", func(t *testing.T) {
+		input := "abc"
+
+		result := TACConfigToModels(input)
+
+		// When ParseUint fails, it logs and returns empty hex string
+		assert.Equal(t, "000000", result) // because tmp is 0 if err != nil
+	})
+}

pkg/service/init_test.go

@@ -0,0 +1,224 @@
+package service
+
+import (
+	"context"
+	"os"
+	"testing"
+	"time"
+
+	amf_context "github.com/free5gc/amf/internal/context"
+	"github.com/free5gc/amf/internal/sbi"
+	"github.com/free5gc/amf/internal/sbi/consumer"
+	"github.com/free5gc/amf/internal/sbi/processor"
+	"github.com/free5gc/amf/pkg/factory"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/mock"
+         "github.com/free5gc/openapi/models"
+)
+
+func TestSetLogLevel(t *testing.T) {
+	config := &factory.Config{}
+	app := &AmfApp{cfg: config}
+
+	app.SetLogLevel("debug")
+	assert.Equal(t, "debug", app.cfg.GetLogLevel())
+
+	app.SetLogLevel("invalid") // should warn, but not panic
+}
+
+func TestSetLogEnable(t *testing.T) {
+	config := &factory.Config{}
+	app := &AmfApp{cfg: config}
+
+	app.SetLogEnable(true)
+
+	app.SetLogEnable(false)
+	assert.False(t, app.cfg.GetLogEnable())
+}
+
+func TestSetReportCaller(t *testing.T) {
+	config := &factory.Config{}
+	app := &AmfApp{cfg: config}
+
+	app.SetReportCaller(true)
+	assert.True(t, app.cfg.GetLogReportCaller())
+
+	app.SetReportCaller(false)
+	assert.False(t, app.cfg.GetLogReportCaller())
+}
+
+func TestSetLogFilePath(t *testing.T) {
+	config := &factory.Config{}
+	app := &AmfApp{cfg: config}
+
+	logFilePath := "/tmp/test_amf_log.log"
+	f, err := os.Create(logFilePath)
+	assert.NoError(t, err)
+	defer f.Close()
+	defer os.Remove(logFilePath)
+
+	app.SetLogFilePath(f)
+	assert.Equal(t, logFilePath, f.Name())
+}
+
+func TestTerminate(t *testing.T) {
+	config := &factory.Config{}
+	ctx, cancel := context.WithCancel(context.Background())
+	app := &AmfApp{cfg: config, ctx: ctx}
+	app.ctx, app.cancel = ctx, cancel
+
+	done := make(chan struct{})
+	go func() {
+		app.Terminate()
+		close(done)
+	}()
+
+	<-done
+}
+
+func TestCancelContext(t *testing.T) {
+	ctx := context.Background()
+	app := &AmfApp{
+		ctx: ctx,
+	}
+	assert.Equal(t, ctx, app.CancelContext())
+}
+func TestWaitRoutineStopped(t *testing.T) {
+	app := &AmfApp{}
+	app.wg.Add(1)
+	go func() {
+		time.Sleep(10 * time.Millisecond)
+		app.wg.Done()
+	}()
+	app.WaitRoutineStopped()
+}
+
+func TestGetters(t *testing.T) {
+	cfg := &factory.Config{}
+	app := &AmfApp{
+		cfg:       cfg,
+		amfCtx:    &amf_context.AMFContext{},
+		consumer:  &consumer.Consumer{},
+		processor: &processor.Processor{},
+	}
+	assert.Equal(t, cfg, app.Config())
+	assert.NotNil(t, app.Context())
+	assert.NotNil(t, app.Consumer())
+	assert.NotNil(t, app.Processor())
+}
+func TestNewApp(t *testing.T) {
+
+	tmpLog := "/tmp/amf_test.log"
+	_ = os.WriteFile(tmpLog, []byte{}, 0644)
+	defer os.Remove(tmpLog)
+
+	cfg := &factory.Config{
+		Configuration: &factory.Configuration{
+			ServiceNameList: []string{
+				string(models.ServiceName_NAMF_COMM),
+				string(models.ServiceName_NAMF_EVTS),
+				string(models.ServiceName_NAMF_MT),
+				string(models.ServiceName_NAMF_LOC),
+				string(models.ServiceName_NAMF_OAM),
+			},
+		},
+	}
+	factory.AmfConfig = cfg
+	app, err := NewApp(context.Background(), cfg, "")
+	assert.NoError(t, err)
+	assert.NotNil(t, app)
+}
+
+
+type MockServerAmf struct {
+	mock.Mock
+
+	Ctx  *amf_context.AMFContext
+	Cfg  *factory.Config
+	Cons *consumer.Consumer
+	Proc *processor.Processor
+}
+
+func (m *MockServerAmf) Init() {}
+
+func (m *MockServerAmf) Run() error {
+	return nil
+}
+
+func (m *MockServerAmf) Terminate() {}
+
+func (m *MockServerAmf) Context() *amf_context.AMFContext {
+	amfCtx := amf_context.GetSelf()
+	amfCtx.NrfUri = "http://nrf.example.com"
+	m.Ctx = amfCtx
+	return m.Ctx
+}
+
+func (m *MockServerAmf) Config() *factory.Config {
+	return m.Cfg
+}
+
+// Wrap the mock inside a dummy real consumer
+func (m *MockServerAmf) Consumer() *consumer.Consumer {
+	c, err := consumer.NewConsumer(AMF)
+	if err != nil {
+		panic("failed to create consumer: " + err.Error()) // fail fast in tests
+	}
+	m.Cons = c
+	return m.Cons
+}
+func (m *MockServerAmf) Processor() *processor.Processor {
+	return m.Proc
+}
+func (m *MockServerAmf) SetLogEnable(enable bool)          {}
+func (m *MockServerAmf) SetLogLevel(level string)          {}
+func (m *MockServerAmf) SetReportCaller(reportCaller bool) {}
+func (m *MockServerAmf) Start()                            {}
+
+// In package consumer
+type DummySCTPListener struct{}
+
+func (d *DummySCTPListener) Close() error {
+	// Pretend to close without doing anything
+	return nil
+}
+func TestListenShutdownEvent_TriggersTerminate(t *testing.T) {
+
+	cfg := &factory.Config{
+		Configuration: &factory.Configuration{
+			NgapIpList:           []string{"127.0.0.1"},
+			NgapPort:             38412,
+			ServedGumaiList:      []models.Guami{},
+			NrfUri:               "http://nrf.example.com",
+			SCTP:                 &factory.Sctp{},
+		},
+	}
+	factory.AmfConfig = cfg
+	amfCtx := amf_context.GetSelf()
+	amfCtx.NrfUri = "http://nrf.example.com"
+	c, err := consumer.NewConsumer(&MockServerAmf{})
+	assert.NoError(t, err)
+	ctx, cancel := context.WithCancel(context.Background())
+
+	app := &AmfApp{
+		cfg:       cfg,
+		ctx:       ctx,
+		cancel:    cancel,
+		amfCtx:    amfCtx,
+		consumer:  c,
+		processor: &processor.Processor{}, // Can mock if needed
+		sbiServer: &sbi.Server{},          // Optional
+	}
+
+	app.wg.Add(1)
+
+	go app.listenShutdownEvent()
+
+	// trigger shutdown
+	cancel()
+	// wait for termination to complete
+	app.wg.Wait()
+}
+
+
+