Improve test coverage

.github/workflows/golangci-lint.yml

@@ -18,4 +18,4 @@ jobs:
       - name: golangci-lint
         uses: golangci/golangci-lint-action@v9
         with:
-          version: v2.7.2
+          version: v2.11.3

api/apiclient/client.go

@@ -127,6 +127,15 @@ func (c *Client) AuthRequests() ([]entity.AuthRequest, error) {
 	return authRequests, nil
 }
 
+func (c *Client) BlockedPeers() ([]config.BlockedPeer, error) {
+	blocked := make([]config.BlockedPeer, 0)
+	err := c.sendGetRequest(api.GetBlockedPeersPath, &blocked)
+	if err != nil {
+		return nil, err
+	}
+	return blocked, nil
+}
+
 func (c *Client) UpdatePeerSettings(request entity.UpdatePeerSettingsRequest) error {
 	return c.sendPostRequest(api.UpdatePeerSettingsPath, request, nil)
 }

api/debug_test.go

@@ -0,0 +1,28 @@
+package api
+
+import (
+	"testing"
+)
+
+func Test_byteCountIEC(t *testing.T) {
+	cases := []struct {
+		input int64
+		want  string
+	}{
+		{0, "0 B"},
+		{1, "1 B"},
+		{1023, "1023 B"},
+		{1024, "1.0 KiB"},
+		{1536, "1.5 KiB"},
+		{1024 * 1024, "1.0 MiB"},
+		{1024 * 1024 * 1024, "1.0 GiB"},
+		{4 * 1024 * 1024 * 1024, "4.0 GiB"},
+	}
+
+	for _, tc := range cases {
+		got := byteCountIEC(tc.input)
+		if got != tc.want {
+			t.Errorf("byteCountIEC(%d) = %q, want %q", tc.input, got, tc.want)
+		}
+	}
+}

api/metrics.go

@@ -38,7 +38,7 @@ func convertBytesToIECUnits(bytesSize float64) string {
 		bytesSize /= unit
 		idx++
 	}
-	label := IECUnits[idx] //nolint:gosec
+	label := IECUnits[idx]
 
 	bytesSize = math.Round(bytesSize*100) / 100
 	bFormatted := strconv.FormatFloat(bytesSize, 'f', -1, 64)

api/peers.go

@@ -314,7 +314,7 @@ func (h *Handler) RemovePeer(c echo.Context) (err error) {
 // @Router /peers/get_blocked [GET]
 func (h *Handler) GetBlockedPeers(c echo.Context) (err error) {
 	h.conf.RLock()
-	result := make([]config.BlockedPeer, 0)
+	result := make([]config.BlockedPeer, 0, len(h.conf.BlockedPeers))
 
 	for _, blockedPeer := range h.conf.BlockedPeers {
 		result = append(result, blockedPeer)

api_handlers_test.go

@@ -0,0 +1,177 @@
+package awl
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"strings"
+	"testing"
+
+	"github.com/anywherelan/awl/api"
+	"github.com/anywherelan/awl/config"
+	"github.com/anywherelan/awl/entity"
+)
+
+func TestExportServerConfiguration(t *testing.T) {
+	ts := NewTestSuite(t)
+
+	peer1 := ts.NewTestPeer(false)
+
+	resp, err := http.Get(fmt.Sprintf("http://%s%s", peer1.app.Api.Address(), api.ExportServerConfigPath))
+	ts.NoError(err)
+	defer resp.Body.Close()
+
+	ts.Equal(http.StatusOK, resp.StatusCode)
+	ts.Contains(resp.Header.Get("Content-Type"), "application/json")
+
+	var cfg config.Config
+	err = json.NewDecoder(resp.Body).Decode(&cfg)
+	ts.NoError(err)
+	ts.Equal(peer1.PeerID(), cfg.P2pNode.PeerID)
+}
+
+func TestUpdateMySettings(t *testing.T) {
+	ts := NewTestSuite(t)
+
+	peer1 := ts.NewTestPeer(false)
+
+	err := peer1.api.UpdateMySettings("new-test-name")
+	ts.NoError(err)
+
+	info, err := peer1.api.PeerInfo()
+	ts.NoError(err)
+	ts.Equal("new-test-name", info.Name)
+}
+
+func TestGetP2pDebugInfo(t *testing.T) {
+	ts := NewTestSuite(t)
+
+	peer1 := ts.NewTestPeer(false)
+
+	debugInfo, err := peer1.api.P2pDebugInfo()
+	ts.NoError(err)
+	ts.NotEmpty(debugInfo.General.Version)
+	ts.NotEmpty(debugInfo.General.Uptime)
+	ts.GreaterOrEqual(debugInfo.Connections.ConnectedPeersCount, 0)
+	ts.GreaterOrEqual(debugInfo.Connections.OpenConnectionsCount, 0)
+	ts.GreaterOrEqual(debugInfo.Connections.OpenStreamsCount, int64(0))
+	ts.NotEmpty(debugInfo.DHT.Reachability)
+}
+
+func TestGetDebugLog(t *testing.T) {
+	ts := NewTestSuite(t)
+
+	peer1 := ts.NewTestPeer(false)
+
+	// Generate some log entries via API calls
+	for range 5 {
+		_, _ = peer1.api.PeerInfo()
+	}
+
+	allLogs, err := peer1.api.ApplicationLog(0, false)
+	ts.NoError(err)
+	ts.NotEmpty(allLogs)
+
+	// Request last 1 line
+	oneLog, err := peer1.api.ApplicationLog(1, false)
+	ts.NoError(err)
+	ts.NotEmpty(oneLog)
+	lines := strings.Split(strings.TrimRight(oneLog, "\n"), "\n")
+	ts.Len(lines, 1)
+
+	// Request first 1 line
+	firstLog, err := peer1.api.ApplicationLog(1, true)
+	ts.NoError(err)
+	ts.NotEmpty(firstLog)
+	firstLines := strings.Split(strings.TrimRight(firstLog, "\n"), "\n")
+	ts.Len(firstLines, 1)
+}
+
+func TestSendFriendRequest_ErrorCases(t *testing.T) {
+	ts := NewTestSuite(t)
+
+	peer1 := ts.NewTestPeer(false)
+
+	t.Run("SelfAdd", func(t *testing.T) {
+		err := peer1.api.SendFriendRequest(peer1.PeerID(), "self", "")
+		ts.Error(err)
+		ts.ErrorContains(err, "You can't add yourself")
+	})
+
+	t.Run("InvalidPeerID", func(t *testing.T) {
+		err := peer1.api.SendFriendRequest("not-a-valid-peer-id", "alias", "")
+		ts.Error(err)
+		ts.ErrorContains(err, "Invalid hex-encoded multihash")
+	})
+}
+
+func TestAcceptFriend_ErrorCases(t *testing.T) {
+	ts := NewTestSuite(t)
+
+	peer1 := ts.NewTestPeer(false)
+	peer2 := ts.NewTestPeer(false)
+
+	t.Run("NoPendingRequest", func(t *testing.T) {
+		err := peer1.api.ReplyFriendRequest(peer2.PeerID(), "peer_2", false, "")
+		ts.Error(err)
+		ts.ErrorContains(err, "Peer did not send you friend request")
+	})
+
+	t.Run("SelfAdd", func(t *testing.T) {
+		err := peer1.api.ReplyFriendRequest(peer1.PeerID(), "self", false, "")
+		ts.Error(err)
+		ts.ErrorContains(err, "You can't add yourself")
+	})
+
+	t.Run("InvalidPeerID", func(t *testing.T) {
+		err := peer1.api.ReplyFriendRequest("bad-peer-id", "alias", false, "")
+		ts.Error(err)
+		ts.ErrorContains(err, "Invalid hex-encoded multihash")
+	})
+}
+
+func TestRemovePeer_PeerNotFound(t *testing.T) {
+	ts := NewTestSuite(t)
+
+	peer1 := ts.NewTestPeer(false)
+	peer2 := ts.NewTestPeer(false)
+
+	// peer2 is not a known peer of peer1
+	err := peer1.api.RemovePeer(peer2.PeerID())
+	ts.Error(err)
+	ts.ErrorContains(err, "peer not found")
+}
+
+func TestUpdatePeerSettings_ErrorCases(t *testing.T) {
+	ts := NewTestSuite(t)
+
+	peer1 := ts.NewTestPeer(false)
+	peer2 := ts.NewTestPeer(false)
+
+	t.Run("PeerNotFound", func(t *testing.T) {
+		err := peer1.api.UpdatePeerSettings(entity.UpdatePeerSettingsRequest{
+			PeerID:     peer2.PeerID(),
+			Alias:      "peer_2",
+			DomainName: "peer2.awl",
+			IPAddr:     "10.66.0.2",
+		})
+		ts.Error(err)
+		ts.ErrorContains(err, "peer not found")
+	})
+
+	t.Run("InvalidDomainName", func(t *testing.T) {
+		ts.makeFriends(peer1, peer2)
+
+		peer2Config, err := peer1.api.KnownPeerConfig(peer2.PeerID())
+		ts.NoError(err)
+
+		err = peer1.api.UpdatePeerSettings(entity.UpdatePeerSettingsRequest{
+			PeerID:     peer2.PeerID(),
+			Alias:      peer2Config.Alias,
+			DomainName: "invalid domain!",
+			IPAddr:     peer2Config.IPAddr,
+		})
+		ts.Error(err)
+		ts.ErrorContains(err, "invalid domain name")
+	})
+}

application_test.go

@@ -115,6 +115,11 @@ func TestDeclinePeerFriendRequest(t *testing.T) {
 	ts.Len(peer2.app.AuthStatus.GetIngoingAuthRequests(), 0)
 	_, blockedPeerExists := peer2.app.Conf.GetBlockedPeer(peer1.PeerID())
 	ts.True(blockedPeerExists)
+
+	blocked, err := peer2.api.BlockedPeers()
+	ts.NoError(err)
+	ts.Len(blocked, 1)
+	ts.Equal(peer1.PeerID(), blocked[0].PeerID)
 }
 
 func TestAutoAcceptFriendRequest(t *testing.T) {