more test cases

.gitignore

@@ -73,3 +73,4 @@ system/bridge.json
 launcher.exe
 web.tar.gz
 __debug_bin.exe
+coverage

generateCoverageReport.bat

@@ -0,0 +1,3 @@
+ go test -cover ./...
+ go test -coverprofile=coverage ./...
+ go tool cover -html=coverage

mod/auth/accesscontrol/blacklist/blacklistmanager_test.go

@@ -0,0 +1,168 @@
+package blacklist
+
+import (
+	"os"
+	"testing"
+
+	"imuslab.com/arozos/mod/database"
+)
+
+var dbFilePath = "../../../test/"
+var dbFileName = "testdb.db"
+var sysDb *database.Database
+
+func setupSuite(t *testing.T) func(t *testing.T) {
+	//t.Log("Setting up database env")
+
+	os.Mkdir(dbFilePath, 0777)
+	file, err := os.Create(dbFilePath + dbFileName)
+	if err != nil {
+		t.Fatalf("Failed to create file: %v", err)
+	}
+	file.Close()
+
+	// Return a function to teardown the test
+	return func(t *testing.T) {
+		//t.Log("Cleaning up")
+		sysDb.Close()
+
+		err := os.RemoveAll(dbFilePath)
+		if err != nil {
+			t.Fatalf("Failed to clean up: %v", err)
+		}
+	}
+}
+
+func TestBlackList_IsBanned(t *testing.T) {
+	teardownSuite := setupSuite(t)
+	defer teardownSuite(t)
+
+	// Create a new database
+	var err error
+	sysDb, err = database.NewDatabase(dbFilePath+dbFileName, false)
+	if err != nil {
+		t.Fatalf("Failed to create a new database: %v", err)
+	}
+
+	bl := NewBlacklistManager(sysDb)
+	bl.SetBlacklistEnabled(true)
+
+	// Test case 1: IP is not banned
+	if bl.IsBanned("192.168.1.1") {
+		t.Error("Expected IP to not be banned")
+	}
+
+	// Test case 2: IP is banned
+	bl.Ban("192.168.1.1")
+	if !bl.IsBanned("192.168.1.1") {
+		t.Error("Expected IP to be banned")
+	}
+
+	// Test case 3: IP range is banned
+	bl.Ban("192.168.2.1-192.168.2.254")
+	//t.Log(err)
+	if !bl.IsBanned("192.168.2.5") {
+		//t.Log(bl.ListBannedIpRanges())
+		t.Error("Expected IP range to be banned")
+	}
+
+	// Test case 4: IP range is not banned
+	if bl.IsBanned("10.0.0.1") {
+		t.Error("Expected IP range to not be banned")
+	}
+}
+
+func TestBlackList_ListBannedIpRanges(t *testing.T) {
+	teardownSuite := setupSuite(t)
+	defer teardownSuite(t)
+
+	// Create a new database
+	var err error
+	sysDb, err = database.NewDatabase(dbFilePath+dbFileName, false)
+	if err != nil {
+		t.Fatalf("Failed to create a new database: %v", err)
+	}
+
+	bl := NewBlacklistManager(sysDb)
+	bl.SetBlacklistEnabled(true)
+
+	// Test case 1: No banned IP ranges
+	if len(bl.ListBannedIpRanges()) != 0 {
+		t.Error("Expected no banned IP ranges")
+	}
+
+	// Test case 2: Banned IP ranges exist
+	bl.Ban("192.168.1.1")
+	bl.Ban("192.168.2.1-192.168.2.254")
+
+	bannedRanges := bl.ListBannedIpRanges()
+	if len(bannedRanges) != 2 {
+		t.Error("Expected 2 banned IP ranges")
+	}
+}
+
+func TestBlackList_Ban_UnBan(t *testing.T) {
+	teardownSuite := setupSuite(t)
+	defer teardownSuite(t)
+
+	// Create a new database
+	var err error
+	sysDb, err = database.NewDatabase(dbFilePath+dbFileName, false)
+	if err != nil {
+		t.Fatalf("Failed to create a new database: %v", err)
+	}
+
+	bl := NewBlacklistManager(sysDb)
+	bl.SetBlacklistEnabled(true)
+
+	// Test case 1: Ban an IP
+	bl.Ban("192.168.1.1")
+	if !bl.IsBanned("192.168.1.1") {
+		t.Error("Expected IP to be banned")
+	}
+
+	// Test case 2: Ban an IP range
+	bl.Ban("192.168.2.1-192.168.2.254")
+	if !bl.IsBanned("192.168.2.5") {
+		t.Error("Expected IP range to be banned")
+	}
+
+	// Test case 3: Unban an IP
+	bl.UnBan("192.168.1.1")
+	if bl.IsBanned("192.168.1.1") {
+		t.Error("Expected IP to be unbanned")
+	}
+
+	// Test case 4: Unban an IP range
+	bl.UnBan("192.168.2.1-192.168.2.254")
+	if bl.IsBanned("192.168.2.5") {
+		t.Error("Expected IP range to be unbanned")
+	}
+}
+
+func TestBlackList_InvalidIpRange(t *testing.T) {
+	teardownSuite := setupSuite(t)
+	defer teardownSuite(t)
+
+	// Create a new database
+	var err error
+	sysDb, err = database.NewDatabase(dbFilePath+dbFileName, false)
+	if err != nil {
+		t.Fatalf("Failed to create a new database: %v", err)
+	}
+
+	bl := NewBlacklistManager(sysDb)
+	bl.SetBlacklistEnabled(true)
+
+	// Test case 1: Ban with invalid IP range
+	err = bl.Ban("invalid-ip-range")
+	if err == nil {
+		t.Error("Expected error for invalid IP range")
+	}
+
+	// Test case 2: Unban with invalid IP range
+	err = bl.UnBan("invalid-ip-range")
+	if err == nil {
+		t.Error("Expected error for invalid IP range")
+	}
+}

mod/auth/accesscontrol/utils_test.go

@@ -0,0 +1,96 @@
+package accesscontrol
+
+import (
+	"testing"
+)
+
+func TestBreakdownIpRange(t *testing.T) {
+	// Test case 1: Single IP
+	result := BreakdownIpRange("192.168.1.1")
+	if len(result) != 1 || result[0] != "192.168.1.1" {
+		t.Error("Expected breakdown result: [192.168.1.1]")
+	}
+
+	// Test case 2: IP range
+	result = BreakdownIpRange("192.168.1.1-192.168.1.5")
+	expected := []string{"192.168.1.1", "192.168.1.2", "192.168.1.3", "192.168.1.4", "192.168.1.5"}
+	if !isEqual(result, expected) {
+		t.Error("Expected breakdown result:", expected)
+	}
+
+	// Test case 3: Invalid IP range
+	result = BreakdownIpRange("invalid-ip-range")
+	if len(result) != 0 {
+		t.Error("Expected empty breakdown result")
+	}
+}
+
+func TestIpInRange(t *testing.T) {
+	// Test case 1: IP in range
+	result := IpInRange("192.168.1.3", "192.168.1.1-192.168.1.5")
+	if !result {
+		t.Error("Expected true for IP in range")
+	}
+
+	// Test case 2: IP not in range
+	result = IpInRange("192.168.2.1", "192.168.1.1-192.168.1.5")
+	if result {
+		t.Error("Expected false for IP not in range")
+	}
+
+	// Test case 3: IP in single IP range
+	result = IpInRange("192.168.1.1", "192.168.1.1")
+	if !result {
+		t.Error("Expected true for IP in single IP range")
+	}
+
+	// Test case 4: IP not in single IP range
+	result = IpInRange("192.168.1.2", "192.168.1.1")
+	if result {
+		t.Error("Expected false for IP not in single IP range")
+	}
+}
+
+func TestValidateIpRange(t *testing.T) {
+	// Test case 1: Valid single IP
+	err := ValidateIpRange("192.168.1.1")
+	if err != nil {
+		t.Error("Expected no error for valid single IP")
+	}
+
+	// Test case 2: Valid IP range
+	err = ValidateIpRange("192.168.1.1-192.168.1.5")
+	if err != nil {
+		t.Error("Expected no error for valid IP range")
+	}
+
+	// Test case 3: Invalid IP range - Starting IP is larger or equal to ending IP
+	err = ValidateIpRange("192.168.1.5-192.168.1.1")
+	if err == nil {
+		t.Error("Expected error for invalid IP range")
+	}
+
+	// Test case 4: Invalid IP range - Subnet mismatch
+	err = ValidateIpRange("192.168.1.1-192.168.2.5")
+	if err == nil {
+		t.Error("Expected error for invalid IP range")
+	}
+
+	// Test case 5: Invalid single IP
+	err = ValidateIpRange("invalid-ip")
+	if err == nil {
+		t.Error("Expected error for invalid single IP")
+	}
+}
+
+func isEqual(slice1, slice2 []string) bool {
+	if len(slice1) != len(slice2) {
+		return false
+	}
+	for i := range slice1 {
+		if slice1[i] != slice2[i] {
+			return false
+		}
+	}
+	return true
+}

mod/auth/accesscontrol/whitelist/whitelist_test.go

@@ -0,0 +1,166 @@
+package whitelist
+
+import (
+	"os"
+	"testing"
+
+	"imuslab.com/arozos/mod/database"
+)
+
+var dbFilePath = "../../../test/"
+var dbFileName = "testdb.db"
+var sysdb *database.Database
+
+func setupSuite(t *testing.T) func(t *testing.T) {
+	//t.Log("Setting up database env")
+
+	os.Mkdir(dbFilePath, 0777)
+	file, err := os.Create(dbFilePath + dbFileName)
+	if err != nil {
+		t.Fatalf("Failed to create file: %v", err)
+	}
+	file.Close()
+
+	// Return a function to teardown the test
+	return func(t *testing.T) {
+		//t.Log("Cleaning up")
+		sysdb.Close()
+
+		err := os.RemoveAll(dbFilePath)
+		if err != nil {
+			t.Fatalf("Failed to clean up: %v", err)
+		}
+	}
+}
+
+func TestWhiteList_SetWhitelistEnabled(t *testing.T) {
+	teardownSuite := setupSuite(t)
+	defer teardownSuite(t)
+
+	// Create a new database
+	var err error
+	sysdb, err = database.NewDatabase(dbFilePath+dbFileName, false)
+	if err != nil {
+		t.Fatalf("Failed to create a new database: %v", err)
+	}
+
+	wl := NewWhitelistManager(sysdb)
+
+	// Test case 1: Enable whitelist
+	wl.SetWhitelistEnabled(true)
+	if !wl.Enabled {
+		t.Error("Expected whitelist to be enabled")
+	}
+
+	// Test case 2: Disable whitelist
+	wl.SetWhitelistEnabled(false)
+	if wl.Enabled {
+		t.Error("Expected whitelist to be disabled")
+	}
+}
+
+func TestWhiteList_IsWhitelisted(t *testing.T) {
+	teardownSuite := setupSuite(t)
+	defer teardownSuite(t)
+
+	// Create a new database
+	var err error
+	sysdb, err = database.NewDatabase(dbFilePath+dbFileName, false)
+	if err != nil {
+		t.Fatalf("Failed to create a new database: %v", err)
+	}
+	wl := NewWhitelistManager(sysdb)
+
+	// Test case 1: IP is whitelisted when whitelist is disabled
+	if !wl.IsWhitelisted("192.168.1.1") {
+		t.Error("Expected IP to be whitelisted when whitelist is disabled")
+	}
+
+	// Test case 2: Enable whitelist and whitelist specific IP
+	wl.SetWhitelistEnabled(true)
+	_ = wl.SetWhitelist("192.168.1.1")
+
+	if !wl.IsWhitelisted("192.168.1.1") || wl.IsWhitelisted("192.168.2.1") {
+		t.Error("Unexpected whitelisting behavior")
+	}
+
+	// Test case 3: Check if reserved IP addresses are always whitelisted
+	if !wl.IsWhitelisted("127.0.0.1") || !wl.IsWhitelisted("localhost") {
+		t.Error("Expected reserved IP addresses to be whitelisted")
+	}
+}
+
+func TestWhiteList_ListWhitelistedIpRanges(t *testing.T) {
+	teardownSuite := setupSuite(t)
+	defer teardownSuite(t)
+
+	// Create a new database
+	var err error
+	sysdb, err = database.NewDatabase(dbFilePath+dbFileName, false)
+	if err != nil {
+		t.Fatalf("Failed to create a new database: %v", err)
+	}
+
+	wl := NewWhitelistManager(sysdb)
+	wl.SetWhitelistEnabled(true)
+
+	// Test case 1: No whitelisted IP ranges
+	if len(wl.ListWhitelistedIpRanges()) != 1 {
+		//t.Log(wl.ListWhitelistedIpRanges())
+		t.Error("Expected no whitelisted IP ranges")
+	}
+
+	// Test case 2: Whitelisted IP ranges exist
+	_ = wl.SetWhitelist("192.168.1.1")
+	_ = wl.SetWhitelist("192.168.2.1-192.168.2.254")
+
+	whitelistedRanges := wl.ListWhitelistedIpRanges()
+	if len(whitelistedRanges) != 3 {
+		t.Error("Expected 3 whitelisted IP ranges")
+	}
+}
+
+func TestWhiteList_SetWhitelist_UnsetWhitelist(t *testing.T) {
+	teardownSuite := setupSuite(t)
+	defer teardownSuite(t)
+
+	// Create a new database
+	var err error
+	sysdb, err = database.NewDatabase(dbFilePath+dbFileName, false)
+	if err != nil {
+		t.Fatalf("Failed to create a new database: %v", err)
+	}
+
+	wl := NewWhitelistManager(sysdb)
+	wl.SetWhitelistEnabled(true)
+
+	// Test case 1: Set whitelist for a specific IP
+	err = wl.SetWhitelist("192.168.1.1")
+	if err != nil || !wl.IsWhitelisted("192.168.1.1") {
+		t.Error("Unexpected error or IP not whitelisted")
+	}
+
+	// Test case 2: Set whitelist for an IP range
+	err = wl.SetWhitelist("192.168.2.1-192.168.2.254")
+	if err != nil || !wl.IsWhitelisted("192.168.2.5") {
+		t.Error("Unexpected error or IP range not whitelisted")
+	}
+
+	// Test case 3: Unset whitelist for a specific IP
+	err = wl.UnsetWhitelist("192.168.1.1")
+	if err != nil || wl.IsWhitelisted("192.168.1.1") {
+		t.Error("Unexpected error or IP still whitelisted")
+	}
+
+	// Test case 4: Unset whitelist for an IP range
+	err = wl.UnsetWhitelist("192.168.2.1-192.168.2.254")
+	if err != nil || wl.IsWhitelisted("192.168.2.5") {
+		t.Error("Unexpected error or IP range still whitelisted")
+	}
+
+	// Test case 5: Unset whitelist for an invalid IP range
+	err = wl.UnsetWhitelist("invalid-ip-range")
+	if err == nil {
+		t.Error("Expected error for invalid IP range")
+	}
+}

mod/auth/authlogger/authlogger_test.go

@@ -11,13 +11,13 @@ import (
 var filePath = "./system/auth/"
 
 func setupSuite(t *testing.T) func(t *testing.T) {
-	t.Log("Setting up env")
+	//t.Log("Setting up env")
 
 	os.Mkdir(filePath, 0777)
 
 	// Return a function to teardown the test
 	return func(t *testing.T) {
-		t.Log("Cleaning up")
+		//t.Log("Cleaning up")
 		err := os.RemoveAll(filePath)
 		os.RemoveAll("./system/")
 		if err != nil {

mod/database/database_core_test.go

@@ -12,7 +12,7 @@ var dbFileName = "testdb.db"
 var db *Database
 
 func setupSuite(t *testing.T) func(t *testing.T) {
-	t.Log("Setting up database env")
+	//t.Log("Setting up database env")
 
 	os.Mkdir(dbFilePath, 0777)
 	file, err := os.Create(dbFilePath + dbFileName)
@@ -23,7 +23,7 @@ func setupSuite(t *testing.T) func(t *testing.T) {
 
 	// Return a function to teardown the test
 	return func(t *testing.T) {
-		t.Log("Cleaning up")
+		//t.Log("Cleaning up")
 		err := os.RemoveAll(dbFilePath)
 		if err != nil {
 			t.Fatalf("Failed to clean up: %v", err)
@@ -81,7 +81,7 @@ func TestDatabaseSimple(t *testing.T) {
 		t.Fatalf("Table still exists after dropping")
 	}
 
-	db.close()
+	defer db.close()
 }
 
 func TestDatabaseComplexRW(t *testing.T) {
@@ -129,5 +129,5 @@ func TestDatabaseComplexRW(t *testing.T) {
 		}
 	}
 
-	db.close()
+	defer db.close()
 }