add

Author: vinod-ship-it

generated/network_services/test/api_ike_crypto_profile_test.go

@@ -237,6 +237,58 @@ func Test_networkservices_IKECryptoProfilesAPIService_List(t *testing.T) {
 	t.Logf("Successfully listed IKE Crypto Profiles, found created profile: %s", profileName)
 }
 
+// Test_networkservices_IKECryptoProfilesAPIService_Fetch tests the fetch convenience method.
+func Test_networkservices_IKECryptoProfilesAPIService_Fetch(t *testing.T) {
+	client := SetupNetworkSvcTestClient(t)
+
+	// Create a profile to fetch by name.
+	profileName := "test-ike-fetch-" + common.GenerateRandomString(6)
+	profile := network_services.IkeCryptoProfiles{
+		Folder:     common.StringPtr("Shared"),
+		Name:       profileName,
+		Hash:       []string{"sha256"},
+		DhGroup:    []string{"group14"},
+		Encryption: []string{"aes-256-cbc"},
+		Lifetime: &network_services.IkeCryptoProfilesLifetime{
+			Hours: common.Int32Ptr(8),
+		},
+	}
+
+	reqCreate := client.IKECryptoProfilesAPI.CreateIKECryptoProfiles(context.Background()).IkeCryptoProfiles(profile)
+	createRes, _, err := reqCreate.Execute()
+	require.NoError(t, err, "Failed to create profile for fetch test")
+	createdProfileID := *createRes.Id
+	createdFolder := createRes.Folder
+	require.NotEmpty(t, createdProfileID, "Created profile ID should not be empty")
+
+	// Defer cleanup.
+	defer func() {
+		t.Logf("Cleaning up IKE Crypto Profile with ID: %s", createdProfileID)
+		_, errDel := client.IKECryptoProfilesAPI.DeleteIKECryptoProfilesByID(context.Background(), createdProfileID).Execute()
+		require.NoError(t, errDel, "Failed to delete profile during cleanup")
+	}()
+
+	// Test Fetch by name operation.
+	fmt.Printf("Attempting to fetch IKE Crypto Profile with name: %s\n", profileName)
+	fetchedProfile, errFetch := client.IKECryptoProfilesAPI.FetchIKECryptoProfiles(context.Background(), profileName, createdFolder, nil, nil)
+
+	// Verify the fetch operation was successful.
+	require.NoError(t, errFetch, "Failed to fetch profile by name")
+	require.NotNil(t, fetchedProfile, "Fetched profile should not be nil")
+	assert.Equal(t, profileName, fetchedProfile.Name, "Profile name should match")
+	assert.Equal(t, createdProfileID, *fetchedProfile.Id, "Profile ID should match")
+	assert.Equal(t, []string{"sha256"}, fetchedProfile.Hash, "Hash should match")
+	assert.Equal(t, *createdFolder, *fetchedProfile.Folder, "Folder should match")
+	t.Logf("Successfully fetched IKE Crypto Profile: %s", profileName)
+
+	// Test fetching non-existent profile (should return nil).
+	nonExistentName := "non-existent-ike-profile-xyz-12345"
+	notFoundProfile, errNotFound := client.IKECryptoProfilesAPI.FetchIKECryptoProfiles(context.Background(), nonExistentName, createdFolder, nil, nil)
+	require.NoError(t, errNotFound, "Fetch for non-existent profile should not error")
+	assert.Nil(t, notFoundProfile, "Non-existent profile should return nil")
+	t.Logf("Successfully verified fetch returns nil for non-existent profile")
+}
+
 // Test_networkservices_IKECryptoProfilesAPIService_DeleteByID tests deleting a profile by ID.
 func Test_networkservices_IKECryptoProfilesAPIService_DeleteByID(t *testing.T) {
 	client := SetupNetworkSvcTestClient(t)

generated/network_services/test/api_ike_gateway_test.go

@@ -195,6 +195,52 @@ func Test_networkservices_IkeGatewaysAPIService_List(t *testing.T) {
 	t.Logf("Successfully listed IKE Gateways and found created gateway: %s", gatewayName)
 }
 
+// Test_networkservices_IkeGatewaysAPIService_Fetch tests the fetch convenience method.
+func Test_networkservices_IkeGatewaysAPIService_Fetch(t *testing.T) {
+	client := SetupNetworkSvcTestClient(t)
+
+	// Create the IKE Crypto Profile dependency first.
+	randomSuffix := common.GenerateRandomString(6)
+	cryptoProfileName := "test-crypto-fetch-" + randomSuffix
+	cryptoProfileID := CreateTestIKECryptoProfile(t, client, cryptoProfileName)
+	defer DeleteTestIKECryptoProfile(t, client, cryptoProfileID, cryptoProfileName)
+
+	// Create a gateway to fetch by name.
+	gatewayName := "auto_ike_gw_fetch-" + randomSuffix
+	gateway := CreateIkeGatewayTestObject(gatewayName, cryptoProfileName)
+	createRes, _, err := client.IKEGatewaysAPI.CreateIKEGateways(context.Background()).IkeGateways(gateway).Execute()
+	require.NoError(t, err, "Failed to create gateway for fetch test")
+	createdGatewayID := *createRes.Id
+	createdFolder := createRes.Folder
+	require.NotEmpty(t, createdGatewayID, "Created gateway ID should not be empty")
+
+	// Defer cleanup.
+	defer func() {
+		t.Logf("Cleaning up IKE Gateway with ID: %s", createdGatewayID)
+		_, errDel := client.IKEGatewaysAPI.DeleteIKEGatewaysByID(context.Background(), createdGatewayID).Execute()
+		require.NoError(t, errDel, "Failed to delete gateway during cleanup")
+	}()
+
+	// Test Fetch by name operation.
+	fmt.Printf("Attempting to fetch IKE Gateway with name: %s\n", gatewayName)
+	fetchedGateway, errFetch := client.IKEGatewaysAPI.FetchIKEGateways(context.Background(), gatewayName, createdFolder, nil, nil)
+
+	// Verify the fetch operation was successful.
+	require.NoError(t, errFetch, "Failed to fetch gateway by name")
+	require.NotNil(t, fetchedGateway, "Fetched gateway should not be nil")
+	assert.Equal(t, gatewayName, fetchedGateway.Name, "Gateway name should match")
+	assert.Equal(t, createdGatewayID, *fetchedGateway.Id, "Gateway ID should match")
+	assert.Equal(t, *createdFolder, *fetchedGateway.Folder, "Folder should match")
+	t.Logf("Successfully fetched IKE Gateway: %s", gatewayName)
+
+	// Test fetching non-existent gateway (should return nil).
+	nonExistentName := "non-existent-ike-gateway-xyz-12345"
+	notFoundGateway, errNotFound := client.IKEGatewaysAPI.FetchIKEGateways(context.Background(), nonExistentName, createdFolder, nil, nil)
+	require.NoError(t, errNotFound, "Fetch for non-existent gateway should not error")
+	assert.Nil(t, notFoundGateway, "Non-existent gateway should return nil")
+	t.Logf("Successfully verified fetch returns nil for non-existent gateway")
+}
+
 // Test_networkservices_IkeGatewaysAPIService_DeleteByID tests deleting an IKE Gateway.
 func Test_networkservices_IkeGatewaysAPIService_DeleteByID(t *testing.T) {
 	client := SetupNetworkSvcTestClient(t)

generated/network_services/test/api_layer2_subinterface_test.go

@@ -300,3 +300,49 @@ func Test_network_services_Layer2SubinterfacesAPIService_List(t *testing.T) {
 	assert.Equal(t, http.StatusOK, httpResList.StatusCode, "Expected 200 OK status")
 	require.NotNil(t, listRes, "List response should not be nil")
 }
+
+// Test_network_services_Layer2SubinterfacesAPIService_Fetch tests the fetch convenience method
+func Test_network_services_Layer2SubinterfacesAPIService_Fetch(t *testing.T) {
+	client := SetupNetworkSvcTestClient(t)
+
+	// --- 1. SETUP PREREQUISITE: Create the L2 Parent Interface ---
+	parentIfName, parentCleanup := setupL2EthernetInterface(t, client)
+	defer parentCleanup()
+
+	// Setup: Create subinterface
+	vlanTag := "999"
+	subIf := createFullLayer2Subinterface(t, parentIfName, vlanTag)
+
+	createRes, _, err := client.Layer2SubinterfacesAPI.CreateLayer2Subinterfaces(context.Background()).Layer2Subinterfaces(subIf).Execute()
+	require.NoError(t, err, "Failed to create Layer 2 Subinterface for fetch test")
+	createdID := *createRes.Id
+	createdName := createRes.Name
+	createdFolder := createRes.Folder
+	require.NotEmpty(t, createdID, "Created subinterface ID should not be empty")
+
+	// Defer cleanup
+	defer func() {
+		t.Logf("Cleaning up Layer 2 Subinterface with ID: %s", createdID)
+		_, errDel := client.Layer2SubinterfacesAPI.DeleteLayer2SubinterfacesByID(context.Background(), createdID).Execute()
+		require.NoError(t, errDel, "Failed to delete subinterface during cleanup")
+	}()
+
+	// Test Fetch by name operation
+	fmt.Printf("Attempting to fetch Layer 2 Subinterface with name: %s\n", createdName)
+	fetchedSubIf, errFetch := client.Layer2SubinterfacesAPI.FetchLayer2Subinterfaces(context.Background(), createdName, createdFolder, nil, nil)
+
+	// Verify the fetch operation was successful
+	require.NoError(t, errFetch, "Failed to fetch subinterface by name")
+	require.NotNil(t, fetchedSubIf, "Fetched subinterface should not be nil")
+	assert.Equal(t, createdName, fetchedSubIf.Name, "Subinterface name should match")
+	assert.Equal(t, createdID, *fetchedSubIf.Id, "Subinterface ID should match")
+	assert.Equal(t, *createdFolder, *fetchedSubIf.Folder, "Folder should match")
+	t.Logf("Successfully fetched Layer 2 Subinterface: %s", createdName)
+
+	// Test fetching non-existent subinterface (should return nil)
+	nonExistentName := "non-existent-layer2-xyz-12345"
+	notFoundSubIf, errNotFound := client.Layer2SubinterfacesAPI.FetchLayer2Subinterfaces(context.Background(), nonExistentName, createdFolder, nil, nil)
+	require.NoError(t, errNotFound, "Fetch for non-existent subinterface should not error")
+	assert.Nil(t, notFoundSubIf, "Non-existent subinterface should return nil")
+	t.Logf("Successfully verified fetch returns nil for non-existent subinterface")
+}

generated/network_services/test/api_layer3_subinterface_test.go

@@ -329,3 +329,52 @@ func Test_network_services_Layer3SubinterfacesAPIService_List(t *testing.T) {
 	assert.Equal(t, http.StatusOK, httpResList.StatusCode, "Expected 200 OK status")
 	require.NotNil(t, listRes, "List response should not be nil")
 }
+
+// Test_network_services_Layer3SubinterfacesAPIService_Fetch tests the fetch convenience method.
+func Test_network_services_Layer3SubinterfacesAPIService_Fetch(t *testing.T) {
+	client := SetupNetworkSvcTestClient(t)
+
+	// --- 1. SETUP PREREQUISITE: Create the L3 Parent Interface ---
+	parentIfName, parentCleanup := setupL3EthernetInterface(t, client)
+	defer parentCleanup()
+
+	// Setup: Create subinterface
+	vlanTag := "888"
+	subIf := createFullLayer3Subinterface(t, parentIfName, vlanTag)
+	subIfName := subIf.GetName()
+
+	reqCreate := client.Layer3SubinterfacesAPI.CreateLayer3Subinterfaces(context.Background()).
+		Layer3Subinterfaces(subIf)
+
+	createRes, _, err := reqCreate.Execute()
+	require.NoError(t, err, "Failed to create Layer 3 Subinterface for fetch test")
+	createdID := *createRes.Id
+	createdFolder := createRes.Folder
+	require.NotEmpty(t, createdID, "Created subinterface ID should not be empty")
+
+	// Defer cleanup
+	defer func() {
+		t.Logf("Cleaning up Layer 3 Subinterface with ID: %s", createdID)
+		_, errDel := client.Layer3SubinterfacesAPI.DeleteLayer3SubinterfacesByID(context.Background(), createdID).Execute()
+		require.NoError(t, errDel, "Failed to delete subinterface during cleanup")
+	}()
+
+	// Test Fetch by name operation
+	fmt.Printf("Attempting to fetch Layer 3 Subinterface with name: %s\n", subIfName)
+	fetchedSubIf, errFetch := client.Layer3SubinterfacesAPI.FetchLayer3Subinterfaces(context.Background(), subIfName, createdFolder, nil, nil)
+
+	// Verify the fetch operation was successful
+	require.NoError(t, errFetch, "Failed to fetch subinterface by name")
+	require.NotNil(t, fetchedSubIf, "Fetched subinterface should not be nil")
+	assert.Equal(t, subIfName, fetchedSubIf.GetName(), "Subinterface name should match")
+	assert.Equal(t, createdID, *fetchedSubIf.Id, "Subinterface ID should match")
+	assert.Equal(t, *createdFolder, fetchedSubIf.GetFolder(), "Folder should match")
+	t.Logf("Successfully fetched Layer 3 Subinterface: %s", subIfName)
+
+	// Test fetching non-existent subinterface (should return nil)
+	nonExistentName := "ethernet1/1.99999"
+	notFoundSubIf, errNotFound := client.Layer3SubinterfacesAPI.FetchLayer3Subinterfaces(context.Background(), nonExistentName, createdFolder, nil, nil)
+	require.NoError(t, errNotFound, "Fetch for non-existent subinterface should not error")
+	assert.Nil(t, notFoundSubIf, "Non-existent subinterface should return nil")
+	t.Logf("Successfully verified fetch returns nil for non-existent subinterface")
+}

generated/network_services/test/api_loopback_interface_test.go

@@ -8,6 +8,7 @@ package network_services
 
 import (
 	"context"
+	"fmt"
 	"net/http"
 	"testing"
 
@@ -187,3 +188,47 @@ func Test_network_services_LoopbackInterfacesAPIService_DeleteByID(t *testing.T)
 	require.NoError(t, errDel, "Failed to delete Loopback Interface")
 	assert.Equal(t, http.StatusOK, httpResDel.StatusCode, "Expected 200 OK status for deletion")
 }
+
+// Test_network_services_LoopbackInterfacesAPIService_Fetch tests the fetch convenience method.
+func Test_network_services_LoopbackInterfacesAPIService_Fetch(t *testing.T) {
+	client := SetupNetworkSvcTestClient(t)
+
+	// Create a Loopback Interface to fetch
+	ifName := generateLoopbackName("loopback-fetch")
+	loopIf := createFullTestLoopbackInterface(t, ifName)
+
+	reqCreate := client.LoopbackInterfacesAPI.CreateLoopbackInterfaces(context.Background()).
+		LoopbackInterfaces(loopIf)
+
+	createRes, _, err := reqCreate.Execute()
+	require.NoError(t, err, "Failed to create Loopback Interface for fetch test")
+	createdID := *createRes.Id
+	createdFolder := createRes.Folder
+	require.NotEmpty(t, createdID, "Created loopback interface ID should not be empty")
+
+	// Defer cleanup
+	defer func() {
+		t.Logf("Cleaning up Loopback Interface with ID: %s", createdID)
+		_, errDel := client.LoopbackInterfacesAPI.DeleteLoopbackInterfacesByID(context.Background(), createdID).Execute()
+		require.NoError(t, errDel, "Failed to delete loopback interface during cleanup")
+	}()
+
+	// Test Fetch by name operation
+	fmt.Printf("Attempting to fetch Loopback Interface with name: %s\n", ifName)
+	fetchedIf, errFetch := client.LoopbackInterfacesAPI.FetchLoopbackInterfaces(context.Background(), ifName, createdFolder, nil, nil)
+
+	// Verify the fetch operation was successful
+	require.NoError(t, errFetch, "Failed to fetch loopback interface by name")
+	require.NotNil(t, fetchedIf, "Fetched loopback interface should not be nil")
+	assert.Equal(t, ifName, fetchedIf.GetName(), "Loopback interface name should match")
+	assert.Equal(t, createdID, *fetchedIf.Id, "Loopback interface ID should match")
+	assert.Equal(t, *createdFolder, fetchedIf.GetFolder(), "Folder should match")
+	t.Logf("Successfully fetched Loopback Interface: %s", ifName)
+
+	// Test fetching non-existent loopback interface (should return nil)
+	nonExistentName := "loopback.99999"
+	notFoundIf, errNotFound := client.LoopbackInterfacesAPI.FetchLoopbackInterfaces(context.Background(), nonExistentName, createdFolder, nil, nil)
+	require.NoError(t, errNotFound, "Fetch for non-existent loopback interface should not error")
+	assert.Nil(t, notFoundIf, "Non-existent loopback interface should return nil")
+	t.Logf("Successfully verified fetch returns nil for non-existent loopback interface")
+}

generated/network_services/test/api_tunnel_interface_test.go

@@ -8,6 +8,7 @@ package network_services
 
 import (
 	"context"
+	"fmt"
 	"net/http"
 	"testing"
 
@@ -195,3 +196,43 @@ func Test_network_services_TunnelInterfacesAPIService_DeleteByID(t *testing.T) {
 	require.NoError(t, errDel, "Failed to delete Tunnel Interface")
 	assert.Equal(t, http.StatusOK, httpResDel.StatusCode, "Expected 200 OK status for deletion")
 }
+
+// Test_network_services_TunnelInterfacesAPIService_Fetch tests the fetch convenience method.
+func Test_network_services_TunnelInterfacesAPIService_Fetch(t *testing.T) {
+	client := SetupNetworkSvcTestClient(t)
+	interfaceName := generateTunnelName("scm-tun-fetch-")
+	tunnelInterface := createFullTestTunnelInterface(t, interfaceName)
+
+	// Setup: Create an interface first
+	createRes, _, err := client.TunnelInterfacesAPI.CreateTunnelInterfaces(context.Background()).TunnelInterfaces(tunnelInterface).Execute()
+	require.NoError(t, err, "Failed to create interface for fetch test")
+	createdID := *createRes.Id
+	createdFolder := createRes.Folder
+	require.NotEmpty(t, createdID, "Created tunnel interface ID should not be empty")
+
+	// Defer cleanup
+	defer func() {
+		t.Logf("Cleaning up Tunnel Interface with ID: %s", createdID)
+		_, errDel := client.TunnelInterfacesAPI.DeleteTunnelInterfacesByID(context.Background(), createdID).Execute()
+		require.NoError(t, errDel, "Failed to delete tunnel interface during cleanup")
+	}()
+
+	// Test Fetch by name operation
+	fmt.Printf("Attempting to fetch Tunnel Interface with name: %s\n", interfaceName)
+	fetchedIf, errFetch := client.TunnelInterfacesAPI.FetchTunnelInterfaces(context.Background(), interfaceName, createdFolder, nil, nil)
+
+	// Verify the fetch operation was successful
+	require.NoError(t, errFetch, "Failed to fetch tunnel interface by name")
+	require.NotNil(t, fetchedIf, "Fetched tunnel interface should not be nil")
+	assert.Equal(t, interfaceName, fetchedIf.GetName(), "Tunnel interface name should match")
+	assert.Equal(t, createdID, *fetchedIf.Id, "Tunnel interface ID should match")
+	assert.Equal(t, *createdFolder, fetchedIf.GetFolder(), "Folder should match")
+	t.Logf("Successfully fetched Tunnel Interface: %s", interfaceName)
+
+	// Test fetching non-existent tunnel interface (should return nil)
+	nonExistentName := "tunnel.99999"
+	notFoundIf, errNotFound := client.TunnelInterfacesAPI.FetchTunnelInterfaces(context.Background(), nonExistentName, createdFolder, nil, nil)
+	require.NoError(t, errNotFound, "Fetch for non-existent tunnel interface should not error")
+	assert.Nil(t, notFoundIf, "Non-existent tunnel interface should return nil")
+	t.Logf("Successfully verified fetch returns nil for non-existent tunnel interface")
+}

generated/network_services/test/api_vlan_interface_test.go

@@ -207,3 +207,45 @@ func Test_network_services_VLANInterfacesAPIService_DeleteByID(t *testing.T) {
 	// The API returns 200 OK for successful deletion.
 	assert.Equal(t, http.StatusOK, httpResDel.StatusCode, "Expected 200 OK status for deletion")
 }
+
+// Test_network_services_VLANInterfacesAPIService_Fetch tests the fetch convenience method.
+func Test_network_services_VLANInterfacesAPIService_Fetch(t *testing.T) {
+	client := SetupNetworkSvcTestClient(t)
+
+	// Create a VLAN Interface to fetch
+	vlanName := "$vlan-fetch-" + common.GenerateRandomString(6)
+	vlanInterface := createFullTestVlanInterface(t, vlanName)
+
+	// Setup: Create an interface first
+	createRes, _, err := client.VLANInterfacesAPI.CreateVLANInterfaces(context.Background()).VlanInterfaces(vlanInterface).Execute()
+	require.NoError(t, err, "Failed to create interface for fetch test")
+	createdID := *createRes.Id
+	createdFolder := createRes.Folder
+	require.NotEmpty(t, createdID, "Created VLAN interface ID should not be empty")
+
+	// Defer cleanup
+	defer func() {
+		t.Logf("Cleaning up VLAN Interface with ID: %s", createdID)
+		_, errDel := client.VLANInterfacesAPI.DeleteVLANInterfacesByID(context.Background(), createdID).Execute()
+		require.NoError(t, errDel, "Failed to delete VLAN interface during cleanup")
+	}()
+
+	// Test Fetch by name operation
+	fmt.Printf("Attempting to fetch VLAN Interface with name: %s\n", vlanName)
+	fetchedIf, errFetch := client.VLANInterfacesAPI.FetchVLANInterfaces(context.Background(), vlanName, createdFolder, nil, nil)
+
+	// Verify the fetch operation was successful
+	require.NoError(t, errFetch, "Failed to fetch VLAN interface by name")
+	require.NotNil(t, fetchedIf, "Fetched VLAN interface should not be nil")
+	assert.Equal(t, vlanName, fetchedIf.GetName(), "VLAN interface name should match")
+	assert.Equal(t, createdID, *fetchedIf.Id, "VLAN interface ID should match")
+	assert.Equal(t, *createdFolder, fetchedIf.GetFolder(), "Folder should match")
+	t.Logf("Successfully fetched VLAN Interface: %s", vlanName)
+
+	// Test fetching non-existent VLAN interface (should return nil)
+	nonExistentName := "vlan.99999"
+	notFoundIf, errNotFound := client.VLANInterfacesAPI.FetchVLANInterfaces(context.Background(), nonExistentName, createdFolder, nil, nil)
+	require.NoError(t, errNotFound, "Fetch for non-existent VLAN interface should not error")
+	assert.Nil(t, notFoundIf, "Non-existent VLAN interface should return nil")
+	t.Logf("Successfully verified fetch returns nil for non-existent VLAN interface")
+}