test: add query checks for RegisteredNodeTransactions

Signed-off-by: dosi <dosi.kolev@limechain.tech>

Author: Dosik13

sdk/registered_node_address_book_query_unit_test.go

@@ -6,28 +6,38 @@ package hiero
 
 import (
 	"net"
+	"net/url"
 	"testing"
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
 
-func TestUnitRegisteredNodeAddressBookQuerySetterChaining(t *testing.T) {
+// ----- setters / getters -----
+
+func TestUnitRegisteredNodeAddressBookQuerySettersChain(t *testing.T) {
 	t.Parallel()
 
 	q := NewRegisteredNodeAddressBookQuery()
 	require.NotNil(t, q)
 
-	result := q.SetRegisteredNodeId(42)
-	assert.Same(t, q, result, "SetRegisteredNodeId should return the same query for chaining")
+	assert.Same(t, q, q.SetRegisteredNodeId(42))
 	assert.Equal(t, uint64(42), q.GetRegisteredNodeId())
+
+	assert.Same(t, q, q.SetLimit(50))
+	assert.Equal(t, int32(50), q.GetLimit())
+
+	assert.Same(t, q, q.SetMaxAttempts(3))
+	assert.Equal(t, uint64(3), q.GetMaxAttempts())
 }
 
-func TestUnitRegisteredNodeAddressBookQueryGetRegisteredNodeIdDefault(t *testing.T) {
+func TestUnitRegisteredNodeAddressBookQueryDefaults(t *testing.T) {
 	t.Parallel()
 
 	q := NewRegisteredNodeAddressBookQuery()
-	assert.Equal(t, uint64(0), q.GetRegisteredNodeId(), "unset ID should default to 0")
+	assert.Equal(t, uint64(0), q.GetRegisteredNodeId())
+	assert.Equal(t, int32(0), q.GetLimit())
+	assert.Equal(t, uint64(0), q.GetMaxAttempts())
 }
 
 func TestUnitRegisteredNodeAddressBookQueryExecuteNilClient(t *testing.T) {
@@ -38,6 +48,89 @@ func TestUnitRegisteredNodeAddressBookQueryExecuteNilClient(t *testing.T) {
 	assert.Equal(t, RegisteredNodeAddressBook{}, book)
 }
 
+// ----- buildURL -----
+
+func TestUnitRegisteredNodeAddressBookQueryBuildURL(t *testing.T) {
+	t.Parallel()
+
+	id := uint64(7)
+	tests := []struct {
+		name string
+		q    *RegisteredNodeAddressBookQuery
+		want string
+	}{
+		{
+			name: "no params",
+			q:    &RegisteredNodeAddressBookQuery{},
+			want: "https://example/api/v1/network/registered-nodes",
+		},
+		{
+			name: "id only",
+			q:    &RegisteredNodeAddressBookQuery{registeredNodeId: &id},
+			want: "https://example/api/v1/network/registered-nodes?registerednode.id=7",
+		},
+		{
+			name: "limit only",
+			q:    &RegisteredNodeAddressBookQuery{limit: 25},
+			want: "https://example/api/v1/network/registered-nodes?limit=25",
+		},
+		{
+			name: "id and limit",
+			q:    &RegisteredNodeAddressBookQuery{registeredNodeId: &id, limit: 25},
+			want: "https://example/api/v1/network/registered-nodes?limit=25&registerednode.id=7",
+		},
+		{
+			name: "limit zero is omitted",
+			q:    &RegisteredNodeAddressBookQuery{registeredNodeId: &id, limit: 0},
+			want: "https://example/api/v1/network/registered-nodes?registerednode.id=7",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			assert.Equal(t, tt.want, tt.q.buildURL("https://example/api/v1"))
+		})
+	}
+}
+
+// ----- resolveNextURL -----
+
+func TestUnitResolveNextURL(t *testing.T) {
+	t.Parallel()
+
+	base, err := url.Parse("https://mirror.example/api/v1")
+	require.NoError(t, err)
+
+	tests := []struct {
+		name string
+		next string
+		want string
+	}{
+		{
+			name: "absolute path replaces base path",
+			next: "/api/v1/network/registered-nodes?limit=25&registerednode.id=gt:5",
+			want: "https://mirror.example/api/v1/network/registered-nodes?limit=25&registerednode.id=gt:5",
+		},
+		{
+			name: "absolute URL passes through",
+			next: "https://other.example/api/v1/network/registered-nodes?limit=25",
+			want: "https://other.example/api/v1/network/registered-nodes?limit=25",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			t.Parallel()
+			got, err := resolveNextURL(base, tt.next)
+			require.NoError(t, err)
+			assert.Equal(t, tt.want, got)
+		})
+	}
+}
+
+// ----- blockNodeApiFromString -----
+
 func TestUnitBlockNodeApiFromString(t *testing.T) {
 	t.Parallel()
 
@@ -52,14 +145,16 @@ func TestUnitBlockNodeApiFromString(t *testing.T) {
 		{"OTHER", BlockNodeApiOther},
 		{"unrecognised", BlockNodeApiOther},
 		{"", BlockNodeApiOther},
-		{"status", BlockNodeApiStatus}, // lower-case should still match
+		{"status", BlockNodeApiStatus},
 	}
 
 	for _, tt := range tests {
 		assert.Equal(t, tt.want, blockNodeApiFromString(tt.in), "input %q", tt.in)
 	}
 }
 
+// ----- adminKeyFromJSON -----
+
 func TestUnitAdminKeyFromJSONEd25519(t *testing.T) {
 	t.Parallel()
 
@@ -69,7 +164,6 @@ func TestUnitAdminKeyFromJSONEd25519(t *testing.T) {
 
 	key, err := adminKeyFromJSON(adminKeyJSON{Type: "ED25519", Key: pub})
 	require.NoError(t, err)
-	require.NotNil(t, key)
 	assert.Equal(t, pub, key.(PublicKey).String())
 }
 
@@ -85,13 +179,27 @@ func TestUnitAdminKeyFromJSONEcdsa(t *testing.T) {
 	require.NotNil(t, key)
 }
 
-func TestUnitAdminKeyFromJSONInvalid(t *testing.T) {
+func TestUnitAdminKeyFromJSONDefaultBranch(t *testing.T) {
+	t.Parallel()
+
+	priv, err := PrivateKeyFromString(mockPrivateKey)
+	require.NoError(t, err)
+	pub := priv.PublicKey().String()
+
+	key, err := adminKeyFromJSON(adminKeyJSON{Type: "MYSTERY", Key: pub})
+	require.NoError(t, err)
+	require.NotNil(t, key)
+}
+
+func TestUnitAdminKeyFromJSONInvalidKey(t *testing.T) {
 	t.Parallel()
 
 	_, err := adminKeyFromJSON(adminKeyJSON{Type: "ED25519", Key: "not-a-key"})
 	assert.Error(t, err)
 }
 
+// ----- serviceEndpointFromJSON -----
+
 func TestUnitServiceEndpointFromJSONBlockNode(t *testing.T) {
 	t.Parallel()
 
@@ -105,15 +213,33 @@ func TestUnitServiceEndpointFromJSONBlockNode(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	block, ok := ep.(*BlockNodeServiceEndpoint)
+	bn, ok := ep.(*BlockNodeServiceEndpoint)
 	require.True(t, ok, "expected *BlockNodeServiceEndpoint")
-	assert.Equal(t, net.IPv4(192, 168, 1, 1).To4(), net.IP(block.GetIPAddress()))
-	assert.Equal(t, uint32(50211), block.GetPort())
-	assert.True(t, block.GetRequiresTls())
-	assert.Equal(t, []BlockNodeApi{BlockNodeApiPublish, BlockNodeApiStatus}, block.GetEndpointApis())
+	assert.Equal(t, []byte(net.ParseIP(ip).To4()), bn.GetIPAddress())
+	assert.Equal(t, uint32(50211), bn.GetPort())
+	assert.True(t, bn.GetRequiresTls())
+	assert.Equal(t, []BlockNodeApi{BlockNodeApiPublish, BlockNodeApiStatus}, bn.GetEndpointApis())
 }
 
-func TestUnitServiceEndpointFromJSONMirrorNode(t *testing.T) {
+func TestUnitServiceEndpointFromJSONMirrorNodeIPv4(t *testing.T) {
+	t.Parallel()
+
+	ip := "10.0.0.1"
+	ep, err := serviceEndpointFromJSON(serviceEndpointJSON{
+		Type:      "MIRROR_NODE",
+		IPAddress: &ip,
+		Port:      443,
+	})
+	require.NoError(t, err)
+
+	mn, ok := ep.(*MirrorNodeServiceEndpoint)
+	require.True(t, ok)
+	assert.Equal(t, []byte(net.ParseIP(ip).To4()), mn.GetIPAddress())
+	assert.Equal(t, uint32(443), mn.GetPort())
+	assert.Empty(t, mn.GetDomainName())
+}
+
+func TestUnitServiceEndpointFromJSONMirrorNodeDomain(t *testing.T) {
 	t.Parallel()
 
 	domain := "mirror.example.com"
@@ -124,39 +250,61 @@ func TestUnitServiceEndpointFromJSONMirrorNode(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	mirror, ok := ep.(*MirrorNodeServiceEndpoint)
-	require.True(t, ok, "expected *MirrorNodeServiceEndpoint")
-	assert.Equal(t, "mirror.example.com", mirror.GetDomainName())
-	assert.Equal(t, uint32(443), mirror.GetPort())
+	mn, ok := ep.(*MirrorNodeServiceEndpoint)
+	require.True(t, ok)
+	assert.Empty(t, mn.GetIPAddress())
+	assert.Equal(t, domain, mn.GetDomainName())
 }
 
 func TestUnitServiceEndpointFromJSONRpcRelay(t *testing.T) {
 	t.Parallel()
 
-	domain := "rpc.example.com"
+	domain := "relay.example.com"
 	ep, err := serviceEndpointFromJSON(serviceEndpointJSON{
 		Type:       "RPC_RELAY",
 		DomainName: &domain,
-		Port:       8545,
+		Port:       7546,
 	})
 	require.NoError(t, err)
 
-	rpc, ok := ep.(*RpcRelayServiceEndpoint)
-	require.True(t, ok, "expected *RpcRelayServiceEndpoint")
-	assert.Equal(t, "rpc.example.com", rpc.GetDomainName())
-	assert.Equal(t, uint32(8545), rpc.GetPort())
+	rr, ok := ep.(*RpcRelayServiceEndpoint)
+	require.True(t, ok)
+	assert.Equal(t, domain, rr.GetDomainName())
+	assert.Equal(t, uint32(7546), rr.GetPort())
 }
 
-func TestUnitServiceEndpointFromJSONUnknownType(t *testing.T) {
+func TestUnitServiceEndpointFromJSONGeneralService(t *testing.T) {
 	t.Parallel()
 
-	domain := "x.example.com"
-	_, err := serviceEndpointFromJSON(serviceEndpointJSON{
-		Type:       "SOMETHING_ELSE",
+	domain := "general.example.com"
+	ep, err := serviceEndpointFromJSON(serviceEndpointJSON{
+		Type:           "GENERAL_SERVICE",
+		DomainName:     &domain,
+		Port:           9000,
+		GeneralService: &generalServiceJSON{Description: "custom-service"},
+	})
+	require.NoError(t, err)
+
+	gs, ok := ep.(*GeneralServiceEndpoint)
+	require.True(t, ok)
+	assert.Equal(t, domain, gs.GetDomainName())
+	assert.Equal(t, "custom-service", gs.GetDescription())
+}
+
+func TestUnitServiceEndpointFromJSONGeneralServiceMissingNested(t *testing.T) {
+	t.Parallel()
+
+	domain := "general.example.com"
+	ep, err := serviceEndpointFromJSON(serviceEndpointJSON{
+		Type:       "GENERAL_SERVICE",
 		DomainName: &domain,
-		Port:       80,
+		Port:       9000,
 	})
-	assert.ErrorContains(t, err, "unknown endpoint type")
+	require.NoError(t, err)
+
+	gs, ok := ep.(*GeneralServiceEndpoint)
+	require.True(t, ok)
+	assert.Empty(t, gs.GetDescription())
 }
 
 func TestUnitServiceEndpointFromJSONIPv6(t *testing.T) {
@@ -170,79 +318,29 @@ func TestUnitServiceEndpointFromJSONIPv6(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	mirror, ok := ep.(*MirrorNodeServiceEndpoint)
-	require.True(t, ok)
-	assert.Equal(t, net.ParseIP(ip).To16(), net.IP(mirror.GetIPAddress()))
+	got := ep.GetIPAddress()
+	require.Len(t, got, 16, "IPv6 should be 16 bytes")
+	assert.Equal(t, []byte(net.ParseIP(ip).To16()), got)
 }
 
 func TestUnitServiceEndpointFromJSONInvalidIP(t *testing.T) {
 	t.Parallel()
 
-	ip := "not-an-ip"
+	bad := "not-an-ip"
 	_, err := serviceEndpointFromJSON(serviceEndpointJSON{
 		Type:      "MIRROR_NODE",
-		IPAddress: &ip,
+		IPAddress: &bad,
 		Port:      443,
 	})
-	assert.ErrorContains(t, err, "invalid IP address")
-}
-
-func TestUnitRegisteredNodeFromJSON(t *testing.T) {
-	t.Parallel()
-
-	priv, err := PrivateKeyFromString(mockPrivateKey)
-	require.NoError(t, err)
-	pub := priv.PublicKey().String()
-
-	ip := "10.0.0.1"
-	domain := "rpc.example.com"
-	raw := registeredNodeJSON{
-		AdminKey:         &adminKeyJSON{Type: "ED25519", Key: pub},
-		CreatedTimestamp: "1700000000.000000000",
-		Description:      "node description",
-		RegisteredNodeID: 7,
-		ServiceEndpoints: []serviceEndpointJSON{
-			{
-				Type:      "BLOCK_NODE",
-				IPAddress: &ip,
-				Port:      50211,
-				BlockNode: &blockNodeJSON{EndpointApis: []string{"PUBLISH"}},
-			},
-			{
-				Type:       "RPC_RELAY",
-				DomainName: &domain,
-				Port:       8545,
-			},
-		},
-	}
-
-	node, err := registeredNodeFromJSON(raw)
-	require.NoError(t, err)
-
-	assert.Equal(t, "node description", node.Description)
-	assert.Equal(t, uint64(7), node.RegisteredNodeID)
-	assert.Equal(t, "1700000000.000000000", node.CreatedTimestamp)
-	require.NotNil(t, node.AdminKey)
-	assert.Equal(t, pub, node.AdminKey.(PublicKey).String())
-	require.Len(t, node.ServiceEndpoints, 2)
-
-	_, isBlock := node.ServiceEndpoints[0].(*BlockNodeServiceEndpoint)
-	assert.True(t, isBlock)
-	_, isRpc := node.ServiceEndpoints[1].(*RpcRelayServiceEndpoint)
-	assert.True(t, isRpc)
+	assert.Error(t, err)
 }
 
-func TestUnitRegisteredNodeFromJSONPropagatesEndpointError(t *testing.T) {
+func TestUnitServiceEndpointFromJSONUnknownType(t *testing.T) {
 	t.Parallel()
 
-	ip := "bad-ip"
-	raw := registeredNodeJSON{
-		RegisteredNodeID: 1,
-		ServiceEndpoints: []serviceEndpointJSON{
-			{Type: "MIRROR_NODE", IPAddress: &ip, Port: 443},
-		},
-	}
-
-	_, err := registeredNodeFromJSON(raw)
-	assert.ErrorContains(t, err, "failed to parse service endpoint")
+	_, err := serviceEndpointFromJSON(serviceEndpointJSON{
+		Type: "MYSTERY",
+		Port: 443,
+	})
+	assert.Error(t, err)
 }