Added more tests

mod/auth/authlogger/authlogger_test.go

@@ -0,0 +1,203 @@
+package authlogger
+
+import (
+	"net/http"
+	"net/url"
+	"os"
+	"testing"
+	"time"
+)
+
+var filePath = "./system/auth/"
+
+func setupSuite(t *testing.T) func(t *testing.T) {
+	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")
+		err := os.RemoveAll(filePath)
+		if err != nil {
+			t.Fatalf("Failed to clean up: %v", err)
+		}
+	}
+}
+
+func TestNewLogger(t *testing.T) {
+	teardownSuite := setupSuite(t)
+	defer teardownSuite(t)
+
+	// Test creating a new logger
+	logger, err := NewLogger()
+	if err != nil {
+		t.Fatalf("Failed to create a new logger: %v", err)
+	}
+	defer logger.Close()
+
+	// Ensure that the logger's database is not nil
+	if logger.database == nil {
+		t.Error("Logger's database should not be nil")
+	}
+}
+
+func TestLogAuth(t *testing.T) {
+	teardownSuite := setupSuite(t)
+	defer teardownSuite(t)
+
+	// Setup a test HTTP request
+	request, err := http.NewRequest("POST", "/login", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	form := url.Values{}
+	form.Add("username", "automatictest")
+
+	request.RemoteAddr = "8.8.8.8:8080"
+	request.PostForm = form
+
+	// Setup a test server to capture the response
+	//rr := httptest.NewRecorder()
+
+	// Create a new logger
+	logger, err := NewLogger()
+	if err != nil {
+		t.Fatalf("Failed to create a new logger: %v", err)
+	}
+	defer logger.Close()
+
+	// Test logging authentication with a successful login
+	err = logger.LogAuth(request, true)
+	if err != nil {
+		t.Fatalf("Failed to log authentication: %v", err)
+	}
+
+	if len(logger.ListSummary()) != 1 {
+		t.Fatalf("Expected list summary:1, curr: 0")
+	}
+
+	summary, err := logger.ListRecords(logger.ListSummary()[0])
+	if err != nil {
+		t.Fatalf("Failed to list records: %v", err)
+	}
+	// should be only 1
+	for _, record := range summary {
+		if record.AuthType != "web" {
+			t.Fatalf("AuthType expected: %v, got: %v", "web", record.AuthType)
+		}
+		if record.IpAddr != "8.8.8.8" {
+			t.Fatalf("IpAddr expected: %v, got: %v", "8.8.8.8", record.IpAddr)
+		}
+		if record.LoginSucceed != true {
+			t.Fatalf("LoginSucceed expected: %v, got: %v", true, record.LoginSucceed)
+		}
+		if record.Port != 8080 {
+			t.Fatalf("Port expected: %v, got: %v", 8080, record.LoginSucceed)
+		}
+		if record.TargetUsername != "automatictest" {
+			t.Fatalf("TargetUsername expected: %v, got: %v", "automatictest", record.TargetUsername)
+		}
+	}
+}
+
+func TestListSummary(t *testing.T) {
+	teardownSuite := setupSuite(t)
+	defer teardownSuite(t)
+
+	// Create a new logger
+	logger, err := NewLogger()
+	if err != nil {
+		t.Fatalf("Failed to create a new logger: %v", err)
+	}
+	defer logger.Close()
+
+	// Test listing summary
+	summary := logger.ListSummary()
+
+	// Assuming there is at least one table in the test environment
+	if len(summary) != 0 {
+		t.Fatal("Expected at least one table in the summary, got none")
+	}
+}
+
+func TestListRecords(t *testing.T) {
+	teardownSuite := setupSuite(t)
+	defer teardownSuite(t)
+
+	// Create a new logger
+	logger, err := NewLogger()
+	if err != nil {
+		t.Fatalf("Failed to create a new logger: %v", err)
+	}
+	defer logger.Close()
+
+	err = logger.LogAuthByRequestInfo("testUser", "192.168.1.1:8080", time.Now().Unix(), true, "custom")
+
+	// Assuming there is at least one table in the test environment
+	summary := logger.ListSummary()
+	if len(summary) == 0 {
+		t.Fatalf("Expected at least one record in the table, got none")
+	}
+
+	// Test listing records from the first table
+	records, err := logger.ListRecords(summary[0])
+	if err != nil {
+		t.Fatalf("Failed to list records: %v", err)
+	}
+
+	// Assuming there are records in the table
+	if len(records) == 0 {
+		t.Fatalf("Expected at least one record in the table, got none")
+	}
+}
+
+func TestLogAuthByRequestInfo(t *testing.T) {
+	teardownSuite := setupSuite(t)
+	defer teardownSuite(t)
+
+	// Create a new logger
+	logger, err := NewLogger()
+	if err != nil {
+		t.Fatalf("Failed to create a new logger: %v", err)
+	}
+	defer logger.Close()
+
+	// Test logging authentication with custom request info
+	tt := time.Now().Unix()
+	err = logger.LogAuthByRequestInfo("testUser", "192.168.1.1:8080", tt, true, "custom")
+	if err != nil {
+		t.Errorf("Failed to log authentication with custom request info: %v", err)
+	}
+
+	if len(logger.ListSummary()) != 1 {
+		t.Fatalf("Expected list summary:1, curr: 0")
+	}
+
+	summary, err := logger.ListRecords(logger.ListSummary()[0])
+	if err != nil {
+		t.Fatalf("Failed to list records: %v", err)
+	}
+	// should be only 1
+	for _, record := range summary {
+		if record.AuthType != "custom" {
+			t.Fatalf("AuthType expected: %v, got: %v", "custom", record.AuthType)
+		}
+		if record.IpAddr != "192.168.1.1" {
+			t.Fatalf("IpAddr expected: %v, got: %v", "192.168.1.1", record.IpAddr)
+		}
+		if record.LoginSucceed != true {
+			t.Fatalf("LoginSucceed expected: %v, got: %v", true, record.LoginSucceed)
+		}
+		if record.Port != 8080 {
+			t.Fatalf("Port expected: %v, got: %v", 8080, record.LoginSucceed)
+		}
+		if record.TargetUsername != "testUser" {
+			t.Fatalf("TargetUsername expected: %v, got: %v", "testUser", record.TargetUsername)
+		}
+		if record.Timestamp != tt {
+			t.Fatalf("Timestamp expected: %v, got: %v", tt, record.Timestamp)
+		}
+	}
+}

mod/auth/authlogger/handlers_test.go

@@ -0,0 +1,92 @@
+package authlogger
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+	"time"
+)
+
+func TestHandleIndexListing(t *testing.T) {
+	teardownSuite := setupSuite(t)
+	defer teardownSuite(t)
+
+	logger, err := NewLogger()
+	if err != nil {
+		t.Fatalf("Failed to create a new logger: %v", err)
+	}
+	defer logger.Close()
+
+	tt := time.Now()
+	err = logger.LogAuthByRequestInfo("testUser", "192.168.1.1:8080", tt.Unix(), true, "custom")
+	if err != nil {
+		t.Fatalf("Failed to create a new entry: %v", err)
+	}
+
+	// Setup a test HTTP request for index listing
+	request, err := http.NewRequest("GET", "/index", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	// Setup a test server to capture the response
+	rr := httptest.NewRecorder()
+
+	// Test handling index listing
+	logger.HandleIndexListing(rr, request)
+
+	// Check the response status code
+	if status := rr.Code; status != http.StatusOK {
+		t.Errorf("HandleIndexListing returned wrong status code: got %v want %v", status, http.StatusOK)
+	}
+
+	// Check the response body
+	expectedBody := `["` + time.Now().UTC().Format("Jan-2006") + `"]`
+	if rr.Body.String() != expectedBody {
+		t.Errorf("HandleIndexListing returned unexpected body: got %v want %v", rr.Body.String(), expectedBody)
+	}
+}
+
+func TestHandleTableListing(t *testing.T) {
+	teardownSuite := setupSuite(t)
+	defer teardownSuite(t)
+
+	logger, err := NewLogger()
+	if err != nil {
+		t.Fatalf("Failed to create a new logger: %v", err)
+	}
+	defer logger.Close()
+
+	tt := time.Now().Unix()
+	err = logger.LogAuthByRequestInfo("testUser", "192.168.1.1:8080", tt, true, "custom")
+	if err != nil {
+		t.Fatalf("Failed to create a new logger: %v", err)
+	}
+
+	// Setup a test HTTP request for table listing
+	request, err := http.NewRequest("POST", "/table", nil)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Post parameter "record" is required
+	request.PostForm = make(map[string][]string)
+	request.PostForm.Add("record", time.Now().UTC().Format("Jan-2006"))
+
+	// Setup a test server to capture the response
+	rr := httptest.NewRecorder()
+
+	// Test handling table listing
+	logger.HandleTableListing(rr, request)
+
+	// Check the response status code
+	if status := rr.Code; status != http.StatusOK {
+		t.Errorf("HandleTableListing returned wrong status code: got %v want %v", status, http.StatusOK)
+	}
+
+	// Check the response body
+	expectedBody := `[{"Timestamp":` + fmt.Sprint(tt) + `,"TargetUsername":"testUser","LoginSucceed":true,"IpAddr":"192.168.1.1","AuthType":"custom","Port":8080}]`
+	if rr.Body.String() != expectedBody {
+		t.Errorf("HandleTableListing returned unexpected body: got %v want %v", rr.Body.String(), expectedBody)
+	}
+}

mod/utils/conv_test.go

@@ -0,0 +1,69 @@
+package utils
+
+import (
+	"testing"
+)
+
+func TestStringToInt64(t *testing.T) {
+	// Test case 1: Valid positive number string
+	result, err := StringToInt64("123")
+	if err != nil || result != 123 {
+		t.Errorf("Test case 1 failed. Expected: 123, Got: %v, Error: %v", result, err)
+	}
+
+	// Test case 2: Valid negative number string
+	result, err = StringToInt64("-456")
+	if err != nil || result != -456 {
+		t.Errorf("Test case 2 failed. Expected: -456, Got: %v, Error: %v", result, err)
+	}
+
+	// Test case 3: Invalid non-number string
+	_, err = StringToInt64("abc")
+	if err == nil {
+		t.Errorf("Test case 3 failed. Expected an error for invalid input.")
+	}
+
+	// Test case 4: Valid zero string
+	result, err = StringToInt64("0")
+	if err != nil || result != 0 {
+		t.Errorf("Test case 4 failed. Expected: 0, Got: %v, Error: %v", result, err)
+	}
+
+	// Test case 5: Valid large positive number string
+	result, err = StringToInt64("9223372036854775807")
+	if err != nil || result != 9223372036854775807 {
+		t.Errorf("Test case 5 failed. Expected: 9223372036854775807, Got: %v, Error: %v", result, err)
+	}
+}
+
+func TestInt64ToString(t *testing.T) {
+	// Test case 1: Valid positive number
+	result := Int64ToString(123)
+	if result != "123" {
+		t.Errorf("Test case 1 failed. Expected: '123', Got: '%s'", result)
+	}
+
+	// Test case 2: Valid negative number
+	result = Int64ToString(-456)
+	if result != "-456" {
+		t.Errorf("Test case 2 failed. Expected: '-456', Got: '%s'", result)
+	}
+
+	// Test case 3: Valid zero
+	result = Int64ToString(0)
+	if result != "0" {
+		t.Errorf("Test case 3 failed. Expected: '0', Got: '%s'", result)
+	}
+
+	// Test case 4: Valid large positive number
+	result = Int64ToString(9223372036854775807)
+	if result != "9223372036854775807" {
+		t.Errorf("Test case 4 failed. Expected: '9223372036854775807', Got: '%s'", result)
+	}
+
+	// Test case 5: Valid large negative number
+	result = Int64ToString(-9223372036854775808)
+	if result != "-9223372036854775808" {
+		t.Errorf("Test case 5 failed. Expected: '-9223372036854775808', Got: '%s'", result)
+	}
+}

mod/utils/utils_test.go

@@ -0,0 +1,96 @@
+package utils
+
+import (
+	"net/http/httptest"
+	"os"
+	"testing"
+	"time"
+)
+
+func TestSendTextResponse(t *testing.T) {
+	w := httptest.NewRecorder()
+	SendTextResponse(w, "Hello, World!")
+
+	if w.Body.String() != "Hello, World!" {
+		t.Errorf("Expected: 'Hello, World!', Got: '%s'", w.Body.String())
+	}
+}
+
+func TestSendJSONResponse(t *testing.T) {
+	w := httptest.NewRecorder()
+	SendJSONResponse(w, `{"key": "value"}`)
+
+	expectedBody := `{"key": "value"}`
+	if w.Body.String() != expectedBody {
+		t.Errorf("Expected: '%s', Got: '%s'", expectedBody, w.Body.String())
+	}
+
+	if w.Header().Get("Content-Type") != "application/json" {
+		t.Error("Content-Type header should be set to 'application/json'")
+	}
+}
+
+func TestSendErrorResponse(t *testing.T) {
+	w := httptest.NewRecorder()
+	SendErrorResponse(w, "Something went wrong")
+
+	expectedBody := `{"error":"Something went wrong"}`
+	if w.Body.String() != expectedBody {
+		t.Errorf("Expected: '%s', Got: '%s'", expectedBody, w.Body.String())
+	}
+
+	if w.Header().Get("Content-Type") != "application/json" {
+		t.Error("Content-Type header should be set to 'application/json'")
+	}
+}
+
+func TestSendOK(t *testing.T) {
+	w := httptest.NewRecorder()
+	SendOK(w)
+
+	expectedBody := `"OK"`
+	if w.Body.String() != expectedBody {
+		t.Errorf("Expected: '%s', Got: '%s'", expectedBody, w.Body.String())
+	}
+
+	if w.Header().Get("Content-Type") != "application/json" {
+		t.Error("Content-Type header should be set to 'application/json'")
+	}
+}
+
+func TestTimeToString(t *testing.T) {
+	testTime := time.Date(2022, 2, 3, 12, 30, 0, 0, time.UTC)
+	result := TimeToString(testTime)
+
+	expectedResult := "2022-02-03 12:30:00"
+	if result != expectedResult {
+		t.Errorf("Expected: '%s', Got: '%s'", expectedResult, result)
+	}
+}
+
+func TestFileExists(t *testing.T) {
+	// Create a temporary file for testing
+	tempFile, err := os.CreateTemp("", "testfile.txt")
+	tempFile.Close()
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.Remove(tempFile.Name())
+
+	t.Log(tempFile.Name())
+	// Test case 1: Existing file
+	exists := FileExists(tempFile.Name())
+	if !exists {
+		t.Errorf("Test case 1 failed. Expected: true, Got: false")
+	}
+
+	// Test case 2: Non-existing file
+	err = os.Remove(tempFile.Name())
+	if err != nil {
+		t.Errorf("OS Remove failed %v", err.Error())
+	}
+	exists = FileExists(tempFile.Name())
+	if exists {
+		t.Errorf("Test case 2 failed. Expected: false, Got: true")
+	}
+}