This is an automated email from the ASF dual-hosted git repository.

davidjumani pushed a commit to branch validate-resp-parsing
in repository https://gitbox.apache.org/repos/asf/cloudstack-go.git

commit 22535d4613e041c7f802e9f9ac0f9aa7ff0dfdf4
Author: davidjumani <[email protected]>
AuthorDate: Fri Jun 10 12:57:00 2022 +0530

    Update test parsing to ensure ID is present
---
 cloudstack/DiskOfferingService.go   |  4 ++
 cloudstack/HostService.go           |  4 ++
 cloudstack/ISOService.go            |  4 ++
 cloudstack/KubernetesService.go     |  4 ++
 cloudstack/cloudstack.go            | 27 +++++++++++--
 generate/generate.go                | 50 ++++++++++++++++++++---
 test/AccountService_test.go         | 30 +++++++++++---
 test/AddressService_test.go         | 10 ++++-
 test/AffinityGroupService_test.go   | 10 ++++-
 test/AnnotationService_test.go      | 15 +++++--
 test/AutoScaleService_test.go       | 50 ++++++++++++++++++-----
 test/BaremetalService_test.go       | 20 ++++++++--
 test/ClusterService_test.go         | 15 +++++--
 test/DiskOfferingService_test.go    | 10 ++++-
 test/DomainService_test.go          | 10 ++++-
 test/FirewallService_test.go        | 30 +++++++++++---
 test/GuestOSService_test.go         | 20 ++++++++--
 test/HostService_test.go            | 45 ++++++++++++++++-----
 test/HypervisorService_test.go      |  5 ++-
 test/ISOService_test.go             | 30 +++++++++++---
 test/ImageStoreService_test.go      | 20 ++++++++--
 test/InternalLBService_test.go      | 20 ++++++++--
 test/KubernetesService_test.go      | 35 ++++++++++++----
 test/LDAPService_test.go            |  5 ++-
 test/LoadBalancerService_test.go    | 35 ++++++++++++----
 test/NATService_test.go             |  5 ++-
 test/NetworkACLService_test.go      | 15 +++++--
 test/NetworkDeviceService_test.go   |  5 ++-
 test/NetworkOfferingService_test.go | 10 ++++-
 test/NetworkService_test.go         | 60 ++++++++++++++++++++++------
 test/NicService_test.go             | 10 ++++-
 test/OvsElementService_test.go      |  5 ++-
 test/PodService_test.go             | 15 +++++--
 test/PoolService_test.go            | 20 ++++++++--
 test/PortableIPService_test.go      |  5 ++-
 test/ProjectService_test.go         | 25 +++++++++---
 test/RoleService_test.go            | 20 ++++++++--
 test/RouterService_test.go          | 35 ++++++++++++----
 test/SSHService_test.go             | 15 +++++--
 test/SecurityGroupService_test.go   |  5 ++-
 test/ServiceOfferingService_test.go | 10 ++++-
 test/SnapshotService_test.go        | 30 +++++++++++---
 test/StoragePoolService_test.go     | 10 ++++-
 test/SwiftService_test.go           |  5 ++-
 test/SystemVMService_test.go        | 35 ++++++++++++----
 test/TemplateService_test.go        | 25 +++++++++---
 test/UCSService_test.go             | 10 ++++-
 test/UsageService_test.go           | 15 +++++--
 test/UserService_test.go            | 30 +++++++++++---
 test/VLANService_test.go            | 10 ++++-
 test/VMGroupService_test.go         | 10 ++++-
 test/VPCService_test.go             | 30 +++++++++++---
 test/VPNService_test.go             | 50 ++++++++++++++++++-----
 test/VirtualMachineService_test.go  | 80 +++++++++++++++++++++++++++++--------
 test/VolumeService_test.go          | 50 ++++++++++++++++++-----
 test/ZoneService_test.go            | 15 +++++--
 test/testdata/SSHService.json       |  1 +
 57 files changed, 949 insertions(+), 225 deletions(-)

diff --git a/cloudstack/DiskOfferingService.go 
b/cloudstack/DiskOfferingService.go
index 863a046..85b886a 100644
--- a/cloudstack/DiskOfferingService.go
+++ b/cloudstack/DiskOfferingService.go
@@ -616,6 +616,10 @@ func (s *DiskOfferingService) CreateDiskOffering(p 
*CreateDiskOfferingParams) (*
                return nil, err
        }
 
+       if resp, err = getRawValue(resp); err != nil {
+               return nil, err
+       }
+
        var r CreateDiskOfferingResponse
        if err := json.Unmarshal(resp, &r); err != nil {
                return nil, err
diff --git a/cloudstack/HostService.go b/cloudstack/HostService.go
index b241677..54e3b44 100644
--- a/cloudstack/HostService.go
+++ b/cloudstack/HostService.go
@@ -744,6 +744,10 @@ func (s *HostService) AddHost(p *AddHostParams) 
(*AddHostResponse, error) {
                return nil, err
        }
 
+       if resp, err = getRawValue(resp); err != nil {
+               return nil, err
+       }
+
        var r AddHostResponse
        if err := json.Unmarshal(resp, &r); err != nil {
                return nil, err
diff --git a/cloudstack/ISOService.go b/cloudstack/ISOService.go
index db285a3..7ed08ff 100644
--- a/cloudstack/ISOService.go
+++ b/cloudstack/ISOService.go
@@ -2033,6 +2033,10 @@ func (s *ISOService) RegisterIso(p *RegisterIsoParams) 
(*RegisterIsoResponse, er
                return nil, err
        }
 
+       if resp, err = getRawValue(resp); err != nil {
+               return nil, err
+       }
+
        var r RegisterIsoResponse
        if err := json.Unmarshal(resp, &r); err != nil {
                return nil, err
diff --git a/cloudstack/KubernetesService.go b/cloudstack/KubernetesService.go
index c01dbff..ba9a870 100644
--- a/cloudstack/KubernetesService.go
+++ b/cloudstack/KubernetesService.go
@@ -218,6 +218,10 @@ func (s *KubernetesService) 
AddKubernetesSupportedVersion(p *AddKubernetesSuppor
                return nil, err
        }
 
+       if resp, err = getRawValue(resp); err != nil {
+               return nil, err
+       }
+
        var r AddKubernetesSupportedVersionResponse
        if err := json.Unmarshal(resp, &r); err != nil {
                return nil, err
diff --git a/cloudstack/cloudstack.go b/cloudstack/cloudstack.go
index 0ca6a12..256a257 100644
--- a/cloudstack/cloudstack.go
+++ b/cloudstack/cloudstack.go
@@ -39,7 +39,7 @@ import (
        "strings"
        "time"
 
-       "github.com/golang/mock/gomock"
+       gomock "github.com/golang/mock/gomock"
 )
 
 // UnlimitedResourceID is a special ID to define an unlimited resource
@@ -533,14 +533,33 @@ func encodeValues(v url.Values) string {
        return buf.String()
 }
 
-// Generic function to get the first raw value from a response as 
json.RawMessage
+// Generic function to get the first non-count raw value from a response as 
json.RawMessage
 func getRawValue(b json.RawMessage) (json.RawMessage, error) {
        var m map[string]json.RawMessage
        if err := json.Unmarshal(b, &m); err != nil {
                return nil, err
        }
-       for _, v := range m {
-               return v, nil
+       getArrayResponse := false
+       for k := range m {
+               if k == "count" {
+                       getArrayResponse = true
+               }
+       }
+       if getArrayResponse {
+               var resp []json.RawMessage
+               for k, v := range m {
+                       if k != "count" {
+                               if err := json.Unmarshal(v, &resp); err != nil {
+                                       return nil, err
+                               }
+                               return resp[0], nil
+                       }
+               }
+
+       } else {
+               for _, v := range m {
+                       return v, nil
+               }
        }
        return nil, fmt.Errorf("Unable to extract the raw value 
from:\n\n%s\n\n", string(b))
 }
diff --git a/generate/generate.go b/generate/generate.go
index a41fe86..70a199b 100644
--- a/generate/generate.go
+++ b/generate/generate.go
@@ -584,14 +584,33 @@ func (as *allServices) GeneralCode() ([]byte, error) {
        pn("    return buf.String()")
        pn("}")
        pn("")
-       pn("// Generic function to get the first raw value from a response as 
json.RawMessage")
+       pn("// Generic function to get the first non-count raw value from a 
response as json.RawMessage")
        pn("func getRawValue(b json.RawMessage) (json.RawMessage, error) {")
        pn("    var m map[string]json.RawMessage")
        pn("    if err := json.Unmarshal(b, &m); err != nil {")
        pn("            return nil, err")
        pn("    }")
-       pn("    for _, v := range m {")
-       pn("            return v, nil")
+       pn("    getArrayResponse := false")
+       pn("    for k := range m {")
+       pn("            if k == \"count\" {")
+       pn("                    getArrayResponse = true")
+       pn("            }")
+       pn("    }")
+       pn("    if getArrayResponse {")
+       pn("            var resp []json.RawMessage")
+       pn("            for k, v := range m {")
+       pn("                    if k != \"count\" {")
+       pn("                            if err := json.Unmarshal(v, &resp); err 
!= nil {")
+       pn("                                    return nil, err")
+       pn("                            }")
+       pn("                            return resp[0], nil")
+       pn("                    }")
+       pn("            }")
+       pn("")
+       pn("    } else {")
+       pn("            for _, v := range m {")
+       pn("                    return v, nil")
+       pn("            }")
        pn("    }")
        pn("    return nil, fmt.Errorf(\"Unable to extract the raw value 
from:\\n\\n%%s\\n\\n\", string(b))")
        pn("}")
@@ -1068,10 +1087,27 @@ func (s *service) generateAPITest(a *API) {
                }
        }
        pn(")")
-       pn("            _, err := client.%s.%s(p)", strings.TrimSuffix(s.name, 
"Service"), capitalize(a.Name))
+       idPresent := false
+       if !(strings.HasPrefix(a.Name, "list") || a.Name == "registerTemplate") 
{
+               for _, ap := range a.Response {
+                       if ap.Name == "id" && ap.Type == "string" {
+                               pn("            r, err := client.%s.%s(p)", 
strings.TrimSuffix(s.name, "Service"), capitalize(a.Name))
+                               idPresent = true
+                               break
+                       }
+               }
+       }
+       if !idPresent {
+               pn("            _, err := client.%s.%s(p)", 
strings.TrimSuffix(s.name, "Service"), capitalize(a.Name))
+       }
        pn("            if err != nil {")
        pn("                    t.Errorf(err.Error())")
        pn("            }")
+       if idPresent {
+               pn("            if r.Id == \"\" {")
+               pn("                    t.Errorf(\"Failed to parse response. ID 
not found\")")
+               pn("            }")
+       }
        pn("    }")
        pn("    t.Run(\"%s\", test%s)", capitalize(a.Name), a.Name)
        pn("")
@@ -1624,7 +1660,11 @@ func (s *service) generateNewAPICallFunc(a *API) {
                "RegisterUserKeys",
                "GetUserKeys",
                "AddAnnotation",
-               "RemoveAnnotation":
+               "RemoveAnnotation",
+               "AddKubernetesSupportedVersion",
+               "CreateDiskOffering",
+               "AddHost",
+               "RegisterIso":
                pn("    if resp, err = getRawValue(resp); err != nil {")
                pn("            return nil, err")
                pn("    }")
diff --git a/test/AccountService_test.go b/test/AccountService_test.go
index bc9487e..be0bbf8 100644
--- a/test/AccountService_test.go
+++ b/test/AccountService_test.go
@@ -40,10 +40,13 @@ func TestAccountService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Account.NewCreateAccountParams("email", 
"firstname", "lastname", "password", "username")
-               _, err := client.Account.CreateAccount(p)
+               r, err := client.Account.CreateAccount(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateAccount", testcreateAccount)
 
@@ -64,10 +67,13 @@ func TestAccountService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Account.NewDisableAccountParams(true)
-               _, err := client.Account.DisableAccount(p)
+               r, err := client.Account.DisableAccount(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DisableAccount", testdisableAccount)
 
@@ -76,10 +82,13 @@ func TestAccountService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Account.NewEnableAccountParams()
-               _, err := client.Account.EnableAccount(p)
+               r, err := client.Account.EnableAccount(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("EnableAccount", testenableAccount)
 
@@ -124,10 +133,13 @@ func TestAccountService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Account.NewLockAccountParams("account", "domainid")
-               _, err := client.Account.LockAccount(p)
+               r, err := client.Account.LockAccount(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("LockAccount", testlockAccount)
 
@@ -136,10 +148,13 @@ func TestAccountService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Account.NewMarkDefaultZoneForAccountParams("account", "domainid", 
"zoneid")
-               _, err := client.Account.MarkDefaultZoneForAccount(p)
+               r, err := client.Account.MarkDefaultZoneForAccount(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("MarkDefaultZoneForAccount", testmarkDefaultZoneForAccount)
 
@@ -148,10 +163,13 @@ func TestAccountService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Account.NewUpdateAccountParams()
-               _, err := client.Account.UpdateAccount(p)
+               r, err := client.Account.UpdateAccount(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateAccount", testupdateAccount)
 
diff --git a/test/AddressService_test.go b/test/AddressService_test.go
index 5a71b71..39a05c8 100644
--- a/test/AddressService_test.go
+++ b/test/AddressService_test.go
@@ -40,10 +40,13 @@ func TestAddressService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Address.NewAssociateIpAddressParams()
-               _, err := client.Address.AssociateIpAddress(p)
+               r, err := client.Address.AssociateIpAddress(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AssociateIpAddress", testassociateIpAddress)
 
@@ -76,10 +79,13 @@ func TestAddressService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Address.NewUpdateIpAddressParams("id")
-               _, err := client.Address.UpdateIpAddress(p)
+               r, err := client.Address.UpdateIpAddress(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateIpAddress", testupdateIpAddress)
 
diff --git a/test/AffinityGroupService_test.go 
b/test/AffinityGroupService_test.go
index e841b4a..ecddf8e 100644
--- a/test/AffinityGroupService_test.go
+++ b/test/AffinityGroupService_test.go
@@ -40,10 +40,13 @@ func TestAffinityGroupService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.AffinityGroup.NewCreateAffinityGroupParams("name", 
"type")
-               _, err := client.AffinityGroup.CreateAffinityGroup(p)
+               r, err := client.AffinityGroup.CreateAffinityGroup(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateAffinityGroup", testcreateAffinityGroup)
 
@@ -88,10 +91,13 @@ func TestAffinityGroupService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.AffinityGroup.NewUpdateVMAffinityGroupParams("id")
-               _, err := client.AffinityGroup.UpdateVMAffinityGroup(p)
+               r, err := client.AffinityGroup.UpdateVMAffinityGroup(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateVMAffinityGroup", testupdateVMAffinityGroup)
 
diff --git a/test/AnnotationService_test.go b/test/AnnotationService_test.go
index 3747ff3..8784c8f 100644
--- a/test/AnnotationService_test.go
+++ b/test/AnnotationService_test.go
@@ -40,10 +40,13 @@ func TestAnnotationService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Annotation.NewAddAnnotationParams()
-               _, err := client.Annotation.AddAnnotation(p)
+               r, err := client.Annotation.AddAnnotation(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddAnnotation", testaddAnnotation)
 
@@ -64,10 +67,13 @@ func TestAnnotationService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Annotation.NewRemoveAnnotationParams("id")
-               _, err := client.Annotation.RemoveAnnotation(p)
+               r, err := client.Annotation.RemoveAnnotation(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("RemoveAnnotation", testremoveAnnotation)
 
@@ -76,10 +82,13 @@ func TestAnnotationService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Annotation.NewUpdateAnnotationVisibilityParams(true, "id")
-               _, err := client.Annotation.UpdateAnnotationVisibility(p)
+               r, err := client.Annotation.UpdateAnnotationVisibility(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateAnnotationVisibility", testupdateAnnotationVisibility)
 
diff --git a/test/AutoScaleService_test.go b/test/AutoScaleService_test.go
index 0eb73f8..18d48a3 100644
--- a/test/AutoScaleService_test.go
+++ b/test/AutoScaleService_test.go
@@ -40,10 +40,13 @@ func TestAutoScaleService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.AutoScale.NewCreateAutoScalePolicyParams("action", 
[]string{}, 0)
-               _, err := client.AutoScale.CreateAutoScalePolicy(p)
+               r, err := client.AutoScale.CreateAutoScalePolicy(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateAutoScalePolicy", testcreateAutoScalePolicy)
 
@@ -52,10 +55,13 @@ func TestAutoScaleService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.AutoScale.NewCreateAutoScaleVmGroupParams("lbruleid", 0, 0, []string{}, 
[]string{}, "vmprofileid")
-               _, err := client.AutoScale.CreateAutoScaleVmGroup(p)
+               r, err := client.AutoScale.CreateAutoScaleVmGroup(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateAutoScaleVmGroup", testcreateAutoScaleVmGroup)
 
@@ -64,10 +70,13 @@ func TestAutoScaleService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.AutoScale.NewCreateAutoScaleVmProfileParams("serviceofferingid", 
"templateid", "zoneid")
-               _, err := client.AutoScale.CreateAutoScaleVmProfile(p)
+               r, err := client.AutoScale.CreateAutoScaleVmProfile(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateAutoScaleVmProfile", testcreateAutoScaleVmProfile)
 
@@ -76,10 +85,13 @@ func TestAutoScaleService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.AutoScale.NewCreateConditionParams("counterid", 
"relationaloperator", 0)
-               _, err := client.AutoScale.CreateCondition(p)
+               r, err := client.AutoScale.CreateCondition(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateCondition", testcreateCondition)
 
@@ -88,10 +100,13 @@ func TestAutoScaleService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.AutoScale.NewCreateCounterParams("name", "source", 
"value")
-               _, err := client.AutoScale.CreateCounter(p)
+               r, err := client.AutoScale.CreateCounter(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateCounter", testcreateCounter)
 
@@ -160,10 +175,13 @@ func TestAutoScaleService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.AutoScale.NewDisableAutoScaleVmGroupParams("id")
-               _, err := client.AutoScale.DisableAutoScaleVmGroup(p)
+               r, err := client.AutoScale.DisableAutoScaleVmGroup(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DisableAutoScaleVmGroup", testdisableAutoScaleVmGroup)
 
@@ -172,10 +190,13 @@ func TestAutoScaleService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.AutoScale.NewEnableAutoScaleVmGroupParams("id")
-               _, err := client.AutoScale.EnableAutoScaleVmGroup(p)
+               r, err := client.AutoScale.EnableAutoScaleVmGroup(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("EnableAutoScaleVmGroup", testenableAutoScaleVmGroup)
 
@@ -244,10 +265,13 @@ func TestAutoScaleService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.AutoScale.NewUpdateAutoScalePolicyParams("id")
-               _, err := client.AutoScale.UpdateAutoScalePolicy(p)
+               r, err := client.AutoScale.UpdateAutoScalePolicy(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateAutoScalePolicy", testupdateAutoScalePolicy)
 
@@ -256,10 +280,13 @@ func TestAutoScaleService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.AutoScale.NewUpdateAutoScaleVmGroupParams("id")
-               _, err := client.AutoScale.UpdateAutoScaleVmGroup(p)
+               r, err := client.AutoScale.UpdateAutoScaleVmGroup(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateAutoScaleVmGroup", testupdateAutoScaleVmGroup)
 
@@ -268,10 +295,13 @@ func TestAutoScaleService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.AutoScale.NewUpdateAutoScaleVmProfileParams("id")
-               _, err := client.AutoScale.UpdateAutoScaleVmProfile(p)
+               r, err := client.AutoScale.UpdateAutoScaleVmProfile(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateAutoScaleVmProfile", testupdateAutoScaleVmProfile)
 
diff --git a/test/BaremetalService_test.go b/test/BaremetalService_test.go
index 77a53ba..a8f4b8b 100644
--- a/test/BaremetalService_test.go
+++ b/test/BaremetalService_test.go
@@ -40,10 +40,13 @@ func TestBaremetalService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Baremetal.NewAddBaremetalDhcpParams("dhcpservertype", "password", 
"physicalnetworkid", "url", "username")
-               _, err := client.Baremetal.AddBaremetalDhcp(p)
+               r, err := client.Baremetal.AddBaremetalDhcp(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddBaremetalDhcp", testaddBaremetalDhcp)
 
@@ -52,10 +55,13 @@ func TestBaremetalService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Baremetal.NewAddBaremetalPxeKickStartServerParams("password", 
"physicalnetworkid", "pxeservertype", "tftpdir", "url", "username")
-               _, err := client.Baremetal.AddBaremetalPxeKickStartServer(p)
+               r, err := client.Baremetal.AddBaremetalPxeKickStartServer(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddBaremetalPxeKickStartServer", 
testaddBaremetalPxeKickStartServer)
 
@@ -64,10 +70,13 @@ func TestBaremetalService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Baremetal.NewAddBaremetalPxePingServerParams("password", 
"physicalnetworkid", "pingdir", "pingstorageserverip", "pxeservertype", 
"tftpdir", "url", "username")
-               _, err := client.Baremetal.AddBaremetalPxePingServer(p)
+               r, err := client.Baremetal.AddBaremetalPxePingServer(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddBaremetalPxePingServer", testaddBaremetalPxePingServer)
 
@@ -76,10 +85,13 @@ func TestBaremetalService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Baremetal.NewAddBaremetalRctParams("baremetalrcturl")
-               _, err := client.Baremetal.AddBaremetalRct(p)
+               r, err := client.Baremetal.AddBaremetalRct(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddBaremetalRct", testaddBaremetalRct)
 
diff --git a/test/ClusterService_test.go b/test/ClusterService_test.go
index d08f0b1..93595aa 100644
--- a/test/ClusterService_test.go
+++ b/test/ClusterService_test.go
@@ -40,10 +40,13 @@ func TestClusterService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Cluster.NewAddClusterParams("clustername", 
"clustertype", "hypervisor", "podid", "zoneid")
-               _, err := client.Cluster.AddCluster(p)
+               r, err := client.Cluster.AddCluster(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddCluster", testaddCluster)
 
@@ -52,10 +55,13 @@ func TestClusterService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Cluster.NewDedicateClusterParams("clusterid", 
"domainid")
-               _, err := client.Cluster.DedicateCluster(p)
+               r, err := client.Cluster.DedicateCluster(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DedicateCluster", testdedicateCluster)
 
@@ -172,10 +178,13 @@ func TestClusterService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Cluster.NewUpdateClusterParams("id")
-               _, err := client.Cluster.UpdateCluster(p)
+               r, err := client.Cluster.UpdateCluster(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateCluster", testupdateCluster)
 
diff --git a/test/DiskOfferingService_test.go b/test/DiskOfferingService_test.go
index 87ed9a9..efe301b 100644
--- a/test/DiskOfferingService_test.go
+++ b/test/DiskOfferingService_test.go
@@ -40,10 +40,13 @@ func TestDiskOfferingService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.DiskOffering.NewCreateDiskOfferingParams("displaytext", "name")
-               _, err := client.DiskOffering.CreateDiskOffering(p)
+               r, err := client.DiskOffering.CreateDiskOffering(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateDiskOffering", testcreateDiskOffering)
 
@@ -76,10 +79,13 @@ func TestDiskOfferingService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.DiskOffering.NewUpdateDiskOfferingParams("id")
-               _, err := client.DiskOffering.UpdateDiskOffering(p)
+               r, err := client.DiskOffering.UpdateDiskOffering(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateDiskOffering", testupdateDiskOffering)
 
diff --git a/test/DomainService_test.go b/test/DomainService_test.go
index cd8dfa5..8d2617d 100644
--- a/test/DomainService_test.go
+++ b/test/DomainService_test.go
@@ -40,10 +40,13 @@ func TestDomainService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Domain.NewCreateDomainParams("name")
-               _, err := client.Domain.CreateDomain(p)
+               r, err := client.Domain.CreateDomain(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateDomain", testcreateDomain)
 
@@ -88,10 +91,13 @@ func TestDomainService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Domain.NewUpdateDomainParams("id")
-               _, err := client.Domain.UpdateDomain(p)
+               r, err := client.Domain.UpdateDomain(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateDomain", testupdateDomain)
 
diff --git a/test/FirewallService_test.go b/test/FirewallService_test.go
index f49ef89..daef845 100644
--- a/test/FirewallService_test.go
+++ b/test/FirewallService_test.go
@@ -64,10 +64,13 @@ func TestFirewallService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Firewall.NewCreateEgressFirewallRuleParams("networkid", "protocol")
-               _, err := client.Firewall.CreateEgressFirewallRule(p)
+               r, err := client.Firewall.CreateEgressFirewallRule(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateEgressFirewallRule", testcreateEgressFirewallRule)
 
@@ -76,10 +79,13 @@ func TestFirewallService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Firewall.NewCreateFirewallRuleParams("ipaddressid", 
"protocol")
-               _, err := client.Firewall.CreateFirewallRule(p)
+               r, err := client.Firewall.CreateFirewallRule(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateFirewallRule", testcreateFirewallRule)
 
@@ -88,10 +94,13 @@ func TestFirewallService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Firewall.NewCreatePortForwardingRuleParams("ipaddressid", 0, "protocol", 
0, "virtualmachineid")
-               _, err := client.Firewall.CreatePortForwardingRule(p)
+               r, err := client.Firewall.CreatePortForwardingRule(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreatePortForwardingRule", testcreatePortForwardingRule)
 
@@ -196,10 +205,13 @@ func TestFirewallService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Firewall.NewUpdateEgressFirewallRuleParams("id")
-               _, err := client.Firewall.UpdateEgressFirewallRule(p)
+               r, err := client.Firewall.UpdateEgressFirewallRule(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateEgressFirewallRule", testupdateEgressFirewallRule)
 
@@ -208,10 +220,13 @@ func TestFirewallService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Firewall.NewUpdateFirewallRuleParams("id")
-               _, err := client.Firewall.UpdateFirewallRule(p)
+               r, err := client.Firewall.UpdateFirewallRule(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateFirewallRule", testupdateFirewallRule)
 
@@ -220,10 +235,13 @@ func TestFirewallService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Firewall.NewUpdatePortForwardingRuleParams("id")
-               _, err := client.Firewall.UpdatePortForwardingRule(p)
+               r, err := client.Firewall.UpdatePortForwardingRule(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdatePortForwardingRule", testupdatePortForwardingRule)
 
diff --git a/test/GuestOSService_test.go b/test/GuestOSService_test.go
index 7877db2..fd794cd 100644
--- a/test/GuestOSService_test.go
+++ b/test/GuestOSService_test.go
@@ -40,10 +40,13 @@ func TestGuestOSService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.GuestOS.NewAddGuestOsParams(map[string]string{}, 
"oscategoryid", "osdisplayname")
-               _, err := client.GuestOS.AddGuestOs(p)
+               r, err := client.GuestOS.AddGuestOs(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddGuestOs", testaddGuestOs)
 
@@ -52,10 +55,13 @@ func TestGuestOSService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.GuestOS.NewAddGuestOsMappingParams("hypervisor", 
"hypervisorversion", "osnameforhypervisor")
-               _, err := client.GuestOS.AddGuestOsMapping(p)
+               r, err := client.GuestOS.AddGuestOsMapping(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddGuestOsMapping", testaddGuestOsMapping)
 
@@ -124,10 +130,13 @@ func TestGuestOSService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.GuestOS.NewUpdateGuestOsParams(map[string]string{}, 
"id", "osdisplayname")
-               _, err := client.GuestOS.UpdateGuestOs(p)
+               r, err := client.GuestOS.UpdateGuestOs(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateGuestOs", testupdateGuestOs)
 
@@ -136,10 +145,13 @@ func TestGuestOSService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.GuestOS.NewUpdateGuestOsMappingParams("id", 
"osnameforhypervisor")
-               _, err := client.GuestOS.UpdateGuestOsMapping(p)
+               r, err := client.GuestOS.UpdateGuestOsMapping(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateGuestOsMapping", testupdateGuestOsMapping)
 
diff --git a/test/HostService_test.go b/test/HostService_test.go
index 1ad6e25..ab46ec9 100644
--- a/test/HostService_test.go
+++ b/test/HostService_test.go
@@ -40,10 +40,13 @@ func TestHostService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Host.NewAddBaremetalHostParams("hypervisor", 
"podid", "url", "zoneid")
-               _, err := client.Host.AddBaremetalHost(p)
+               r, err := client.Host.AddBaremetalHost(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddBaremetalHost", testaddBaremetalHost)
 
@@ -64,10 +67,13 @@ func TestHostService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Host.NewAddHostParams("hypervisor", "podid", "url", 
"zoneid")
-               _, err := client.Host.AddHost(p)
+               r, err := client.Host.AddHost(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddHost", testaddHost)
 
@@ -76,10 +82,13 @@ func TestHostService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Host.NewAddSecondaryStorageParams("url")
-               _, err := client.Host.AddSecondaryStorage(p)
+               r, err := client.Host.AddSecondaryStorage(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddSecondaryStorage", testaddSecondaryStorage)
 
@@ -88,10 +97,13 @@ func TestHostService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Host.NewCancelHostMaintenanceParams("id")
-               _, err := client.Host.CancelHostMaintenance(p)
+               r, err := client.Host.CancelHostMaintenance(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CancelHostMaintenance", testcancelHostMaintenance)
 
@@ -124,10 +136,13 @@ func TestHostService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Host.NewDedicateHostParams("domainid", "hostid")
-               _, err := client.Host.DedicateHost(p)
+               r, err := client.Host.DedicateHost(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DedicateHost", testdedicateHost)
 
@@ -172,10 +187,13 @@ func TestHostService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Host.NewFindHostsForMigrationParams("virtualmachineid")
-               _, err := client.Host.FindHostsForMigration(p)
+               r, err := client.Host.FindHostsForMigration(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("FindHostsForMigration", testfindHostsForMigration)
 
@@ -232,10 +250,13 @@ func TestHostService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Host.NewPrepareHostForMaintenanceParams("id")
-               _, err := client.Host.PrepareHostForMaintenance(p)
+               r, err := client.Host.PrepareHostForMaintenance(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("PrepareHostForMaintenance", testprepareHostForMaintenance)
 
@@ -244,10 +265,13 @@ func TestHostService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Host.NewReconnectHostParams("id")
-               _, err := client.Host.ReconnectHost(p)
+               r, err := client.Host.ReconnectHost(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ReconnectHost", testreconnectHost)
 
@@ -280,10 +304,13 @@ func TestHostService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Host.NewUpdateHostParams("id")
-               _, err := client.Host.UpdateHost(p)
+               r, err := client.Host.UpdateHost(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateHost", testupdateHost)
 
diff --git a/test/HypervisorService_test.go b/test/HypervisorService_test.go
index e0ec6ca..27facfb 100644
--- a/test/HypervisorService_test.go
+++ b/test/HypervisorService_test.go
@@ -64,10 +64,13 @@ func TestHypervisorService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Hypervisor.NewUpdateHypervisorCapabilitiesParams()
-               _, err := client.Hypervisor.UpdateHypervisorCapabilities(p)
+               r, err := client.Hypervisor.UpdateHypervisorCapabilities(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateHypervisorCapabilities", testupdateHypervisorCapabilities)
 
diff --git a/test/ISOService_test.go b/test/ISOService_test.go
index 01d397c..b9e6d89 100644
--- a/test/ISOService_test.go
+++ b/test/ISOService_test.go
@@ -40,10 +40,13 @@ func TestISOService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.ISO.NewAttachIsoParams("id", "virtualmachineid")
-               _, err := client.ISO.AttachIso(p)
+               r, err := client.ISO.AttachIso(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AttachIso", testattachIso)
 
@@ -52,10 +55,13 @@ func TestISOService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.ISO.NewCopyIsoParams("id")
-               _, err := client.ISO.CopyIso(p)
+               r, err := client.ISO.CopyIso(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CopyIso", testcopyIso)
 
@@ -76,10 +82,13 @@ func TestISOService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.ISO.NewDetachIsoParams("virtualmachineid")
-               _, err := client.ISO.DetachIso(p)
+               r, err := client.ISO.DetachIso(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DetachIso", testdetachIso)
 
@@ -88,10 +97,13 @@ func TestISOService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.ISO.NewExtractIsoParams("id", "mode")
-               _, err := client.ISO.ExtractIso(p)
+               r, err := client.ISO.ExtractIso(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ExtractIso", testextractIso)
 
@@ -124,10 +136,13 @@ func TestISOService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.ISO.NewRegisterIsoParams("displaytext", "name", 
"url", "zoneid")
-               _, err := client.ISO.RegisterIso(p)
+               r, err := client.ISO.RegisterIso(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("RegisterIso", testregisterIso)
 
@@ -136,10 +151,13 @@ func TestISOService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.ISO.NewUpdateIsoParams("id")
-               _, err := client.ISO.UpdateIso(p)
+               r, err := client.ISO.UpdateIso(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateIso", testupdateIso)
 
diff --git a/test/ImageStoreService_test.go b/test/ImageStoreService_test.go
index 31fee6a..1b04fa1 100644
--- a/test/ImageStoreService_test.go
+++ b/test/ImageStoreService_test.go
@@ -40,10 +40,13 @@ func TestImageStoreService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.ImageStore.NewAddImageStoreParams("provider")
-               _, err := client.ImageStore.AddImageStore(p)
+               r, err := client.ImageStore.AddImageStore(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddImageStore", testaddImageStore)
 
@@ -52,10 +55,13 @@ func TestImageStoreService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.ImageStore.NewAddImageStoreS3Params("accesskey", 
"bucket", "endpoint", "secretkey")
-               _, err := client.ImageStore.AddImageStoreS3(p)
+               r, err := client.ImageStore.AddImageStoreS3(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddImageStoreS3", testaddImageStoreS3)
 
@@ -64,10 +70,13 @@ func TestImageStoreService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.ImageStore.NewCreateSecondaryStagingStoreParams("url")
-               _, err := client.ImageStore.CreateSecondaryStagingStore(p)
+               r, err := client.ImageStore.CreateSecondaryStagingStore(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateSecondaryStagingStore", testcreateSecondaryStagingStore)
 
@@ -124,10 +133,13 @@ func TestImageStoreService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.ImageStore.NewUpdateCloudToUseObjectStoreParams("provider")
-               _, err := client.ImageStore.UpdateCloudToUseObjectStore(p)
+               r, err := client.ImageStore.UpdateCloudToUseObjectStore(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateCloudToUseObjectStore", testupdateCloudToUseObjectStore)
 
diff --git a/test/InternalLBService_test.go b/test/InternalLBService_test.go
index 7477127..c389f2d 100644
--- a/test/InternalLBService_test.go
+++ b/test/InternalLBService_test.go
@@ -40,10 +40,13 @@ func TestInternalLBService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.InternalLB.NewConfigureInternalLoadBalancerElementParams(true, "id")
-               _, err := 
client.InternalLB.ConfigureInternalLoadBalancerElement(p)
+               r, err := 
client.InternalLB.ConfigureInternalLoadBalancerElement(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ConfigureInternalLoadBalancerElement", 
testconfigureInternalLoadBalancerElement)
 
@@ -52,10 +55,13 @@ func TestInternalLBService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.InternalLB.NewCreateInternalLoadBalancerElementParams("nspid")
-               _, err := client.InternalLB.CreateInternalLoadBalancerElement(p)
+               r, err := client.InternalLB.CreateInternalLoadBalancerElement(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateInternalLoadBalancerElement", 
testcreateInternalLoadBalancerElement)
 
@@ -88,10 +94,13 @@ func TestInternalLBService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.InternalLB.NewStartInternalLoadBalancerVMParams("id")
-               _, err := client.InternalLB.StartInternalLoadBalancerVM(p)
+               r, err := client.InternalLB.StartInternalLoadBalancerVM(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("StartInternalLoadBalancerVM", teststartInternalLoadBalancerVM)
 
@@ -100,10 +109,13 @@ func TestInternalLBService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.InternalLB.NewStopInternalLoadBalancerVMParams("id")
-               _, err := client.InternalLB.StopInternalLoadBalancerVM(p)
+               r, err := client.InternalLB.StopInternalLoadBalancerVM(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("StopInternalLoadBalancerVM", teststopInternalLoadBalancerVM)
 
diff --git a/test/KubernetesService_test.go b/test/KubernetesService_test.go
index 4b4ceb6..350b3e7 100644
--- a/test/KubernetesService_test.go
+++ b/test/KubernetesService_test.go
@@ -40,10 +40,13 @@ func TestKubernetesService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Kubernetes.NewAddKubernetesSupportedVersionParams(0, 0, 
"semanticversion")
-               _, err := client.Kubernetes.AddKubernetesSupportedVersion(p)
+               r, err := client.Kubernetes.AddKubernetesSupportedVersion(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddKubernetesSupportedVersion", 
testaddKubernetesSupportedVersion)
 
@@ -52,10 +55,13 @@ func TestKubernetesService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Kubernetes.NewCreateKubernetesClusterParams("description", 
"kubernetesversionid", "name", "serviceofferingid", 0, "zoneid")
-               _, err := client.Kubernetes.CreateKubernetesCluster(p)
+               r, err := client.Kubernetes.CreateKubernetesCluster(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateKubernetesCluster", testcreateKubernetesCluster)
 
@@ -88,10 +94,13 @@ func TestKubernetesService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Kubernetes.NewGetKubernetesClusterConfigParams()
-               _, err := client.Kubernetes.GetKubernetesClusterConfig(p)
+               r, err := client.Kubernetes.GetKubernetesClusterConfig(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("GetKubernetesClusterConfig", testgetKubernetesClusterConfig)
 
@@ -124,10 +133,13 @@ func TestKubernetesService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Kubernetes.NewScaleKubernetesClusterParams("id")
-               _, err := client.Kubernetes.ScaleKubernetesCluster(p)
+               r, err := client.Kubernetes.ScaleKubernetesCluster(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ScaleKubernetesCluster", testscaleKubernetesCluster)
 
@@ -136,10 +148,13 @@ func TestKubernetesService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Kubernetes.NewStartKubernetesClusterParams("id")
-               _, err := client.Kubernetes.StartKubernetesCluster(p)
+               r, err := client.Kubernetes.StartKubernetesCluster(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("StartKubernetesCluster", teststartKubernetesCluster)
 
@@ -160,10 +175,13 @@ func TestKubernetesService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Kubernetes.NewUpdateKubernetesSupportedVersionParams("id", "state")
-               _, err := client.Kubernetes.UpdateKubernetesSupportedVersion(p)
+               r, err := client.Kubernetes.UpdateKubernetesSupportedVersion(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateKubernetesSupportedVersion", 
testupdateKubernetesSupportedVersion)
 
@@ -172,10 +190,13 @@ func TestKubernetesService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Kubernetes.NewUpgradeKubernetesClusterParams("id", 
"kubernetesversionid")
-               _, err := client.Kubernetes.UpgradeKubernetesCluster(p)
+               r, err := client.Kubernetes.UpgradeKubernetesCluster(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpgradeKubernetesCluster", testupgradeKubernetesCluster)
 
diff --git a/test/LDAPService_test.go b/test/LDAPService_test.go
index 15e852d..eb3632d 100644
--- a/test/LDAPService_test.go
+++ b/test/LDAPService_test.go
@@ -88,10 +88,13 @@ func TestLDAPService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.LDAP.NewLdapCreateAccountParams("username")
-               _, err := client.LDAP.LdapCreateAccount(p)
+               r, err := client.LDAP.LdapCreateAccount(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("LdapCreateAccount", testldapCreateAccount)
 
diff --git a/test/LoadBalancerService_test.go b/test/LoadBalancerService_test.go
index 00131f1..ac7dd43 100644
--- a/test/LoadBalancerService_test.go
+++ b/test/LoadBalancerService_test.go
@@ -100,10 +100,13 @@ func TestLoadBalancerService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.LoadBalancer.NewCreateGlobalLoadBalancerRuleParams("gslbdomainname", 
"gslbservicetype", "name", 0)
-               _, err := client.LoadBalancer.CreateGlobalLoadBalancerRule(p)
+               r, err := client.LoadBalancer.CreateGlobalLoadBalancerRule(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateGlobalLoadBalancerRule", testcreateGlobalLoadBalancerRule)
 
@@ -136,10 +139,13 @@ func TestLoadBalancerService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.LoadBalancer.NewCreateLoadBalancerParams("algorithm", 0, "name", 
"networkid", "scheme", "sourceipaddressnetworkid", 0)
-               _, err := client.LoadBalancer.CreateLoadBalancer(p)
+               r, err := client.LoadBalancer.CreateLoadBalancer(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateLoadBalancer", testcreateLoadBalancer)
 
@@ -148,10 +154,13 @@ func TestLoadBalancerService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.LoadBalancer.NewCreateLoadBalancerRuleParams("algorithm", "name", 0, 0)
-               _, err := client.LoadBalancer.CreateLoadBalancerRule(p)
+               r, err := client.LoadBalancer.CreateLoadBalancerRule(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateLoadBalancerRule", testcreateLoadBalancerRule)
 
@@ -376,10 +385,13 @@ func TestLoadBalancerService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.LoadBalancer.NewUpdateGlobalLoadBalancerRuleParams("id")
-               _, err := client.LoadBalancer.UpdateGlobalLoadBalancerRule(p)
+               r, err := client.LoadBalancer.UpdateGlobalLoadBalancerRule(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateGlobalLoadBalancerRule", testupdateGlobalLoadBalancerRule)
 
@@ -412,10 +424,13 @@ func TestLoadBalancerService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.LoadBalancer.NewUpdateLoadBalancerParams("id")
-               _, err := client.LoadBalancer.UpdateLoadBalancer(p)
+               r, err := client.LoadBalancer.UpdateLoadBalancer(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateLoadBalancer", testupdateLoadBalancer)
 
@@ -424,10 +439,13 @@ func TestLoadBalancerService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.LoadBalancer.NewUpdateLoadBalancerRuleParams("id")
-               _, err := client.LoadBalancer.UpdateLoadBalancerRule(p)
+               r, err := client.LoadBalancer.UpdateLoadBalancerRule(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateLoadBalancerRule", testupdateLoadBalancerRule)
 
@@ -436,10 +454,13 @@ func TestLoadBalancerService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.LoadBalancer.NewUploadSslCertParams("certificate", 
"name", "privatekey")
-               _, err := client.LoadBalancer.UploadSslCert(p)
+               r, err := client.LoadBalancer.UploadSslCert(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UploadSslCert", testuploadSslCert)
 
diff --git a/test/NATService_test.go b/test/NATService_test.go
index b57322a..b79e1d6 100644
--- a/test/NATService_test.go
+++ b/test/NATService_test.go
@@ -40,10 +40,13 @@ func TestNATService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.NAT.NewCreateIpForwardingRuleParams("ipaddressid", 
"protocol", 0)
-               _, err := client.NAT.CreateIpForwardingRule(p)
+               r, err := client.NAT.CreateIpForwardingRule(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateIpForwardingRule", testcreateIpForwardingRule)
 
diff --git a/test/NetworkACLService_test.go b/test/NetworkACLService_test.go
index 4364ecf..b20e352 100644
--- a/test/NetworkACLService_test.go
+++ b/test/NetworkACLService_test.go
@@ -40,10 +40,13 @@ func TestNetworkACLService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.NetworkACL.NewCreateNetworkACLParams("protocol")
-               _, err := client.NetworkACL.CreateNetworkACL(p)
+               r, err := client.NetworkACL.CreateNetworkACL(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateNetworkACL", testcreateNetworkACL)
 
@@ -52,10 +55,13 @@ func TestNetworkACLService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.NetworkACL.NewCreateNetworkACLListParams("name", 
"vpcid")
-               _, err := client.NetworkACL.CreateNetworkACLList(p)
+               r, err := client.NetworkACL.CreateNetworkACLList(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateNetworkACLList", testcreateNetworkACLList)
 
@@ -124,10 +130,13 @@ func TestNetworkACLService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.NetworkACL.NewUpdateNetworkACLItemParams("id")
-               _, err := client.NetworkACL.UpdateNetworkACLItem(p)
+               r, err := client.NetworkACL.UpdateNetworkACLItem(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateNetworkACLItem", testupdateNetworkACLItem)
 
diff --git a/test/NetworkDeviceService_test.go 
b/test/NetworkDeviceService_test.go
index 47b8613..fdc4b55 100644
--- a/test/NetworkDeviceService_test.go
+++ b/test/NetworkDeviceService_test.go
@@ -40,10 +40,13 @@ func TestNetworkDeviceService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.NetworkDevice.NewAddNetworkDeviceParams()
-               _, err := client.NetworkDevice.AddNetworkDevice(p)
+               r, err := client.NetworkDevice.AddNetworkDevice(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddNetworkDevice", testaddNetworkDevice)
 
diff --git a/test/NetworkOfferingService_test.go 
b/test/NetworkOfferingService_test.go
index 839b0a2..50bcb34 100644
--- a/test/NetworkOfferingService_test.go
+++ b/test/NetworkOfferingService_test.go
@@ -40,10 +40,13 @@ func TestNetworkOfferingService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.NetworkOffering.NewCreateNetworkOfferingParams("displaytext", 
"guestiptype", "name", "traffictype")
-               _, err := client.NetworkOffering.CreateNetworkOffering(p)
+               r, err := client.NetworkOffering.CreateNetworkOffering(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateNetworkOffering", testcreateNetworkOffering)
 
@@ -76,10 +79,13 @@ func TestNetworkOfferingService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.NetworkOffering.NewUpdateNetworkOfferingParams()
-               _, err := client.NetworkOffering.UpdateNetworkOffering(p)
+               r, err := client.NetworkOffering.UpdateNetworkOffering(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateNetworkOffering", testupdateNetworkOffering)
 
diff --git a/test/NetworkService_test.go b/test/NetworkService_test.go
index e1c5d9a..930cea8 100644
--- a/test/NetworkService_test.go
+++ b/test/NetworkService_test.go
@@ -40,10 +40,13 @@ func TestNetworkService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Network.NewAddNetworkServiceProviderParams("name", 
"physicalnetworkid")
-               _, err := client.Network.AddNetworkServiceProvider(p)
+               r, err := client.Network.AddNetworkServiceProvider(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddNetworkServiceProvider", testaddNetworkServiceProvider)
 
@@ -52,10 +55,13 @@ func TestNetworkService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Network.NewAddOpenDaylightControllerParams("password", 
"physicalnetworkid", "url", "username")
-               _, err := client.Network.AddOpenDaylightController(p)
+               r, err := client.Network.AddOpenDaylightController(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddOpenDaylightController", testaddOpenDaylightController)
 
@@ -64,10 +70,13 @@ func TestNetworkService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Network.NewCreateNetworkParams("displaytext", 
"name", "networkofferingid", "zoneid")
-               _, err := client.Network.CreateNetwork(p)
+               r, err := client.Network.CreateNetwork(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateNetwork", testcreateNetwork)
 
@@ -76,10 +85,13 @@ func TestNetworkService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Network.NewCreatePhysicalNetworkParams("name", 
"zoneid")
-               _, err := client.Network.CreatePhysicalNetwork(p)
+               r, err := client.Network.CreatePhysicalNetwork(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreatePhysicalNetwork", testcreatePhysicalNetwork)
 
@@ -88,10 +100,13 @@ func TestNetworkService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Network.NewCreateServiceInstanceParams("leftnetworkid", "name", 
"rightnetworkid", "serviceofferingid", "templateid", "zoneid")
-               _, err := client.Network.CreateServiceInstance(p)
+               r, err := client.Network.CreateServiceInstance(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateServiceInstance", testcreateServiceInstance)
 
@@ -100,10 +115,13 @@ func TestNetworkService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Network.NewCreateStorageNetworkIpRangeParams("gateway", "netmask", 
"podid", "startip")
-               _, err := client.Network.CreateStorageNetworkIpRange(p)
+               r, err := client.Network.CreateStorageNetworkIpRange(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateStorageNetworkIpRange", testcreateStorageNetworkIpRange)
 
@@ -112,10 +130,13 @@ func TestNetworkService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Network.NewDedicatePublicIpRangeParams("domainid", 
"id")
-               _, err := client.Network.DedicatePublicIpRange(p)
+               r, err := client.Network.DedicatePublicIpRange(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DedicatePublicIpRange", testdedicatePublicIpRange)
 
@@ -148,10 +169,13 @@ func TestNetworkService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Network.NewDeleteOpenDaylightControllerParams("id")
-               _, err := client.Network.DeleteOpenDaylightController(p)
+               r, err := client.Network.DeleteOpenDaylightController(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DeleteOpenDaylightController", testdeleteOpenDaylightController)
 
@@ -328,10 +352,13 @@ func TestNetworkService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Network.NewUpdateNetworkParams("id")
-               _, err := client.Network.UpdateNetwork(p)
+               r, err := client.Network.UpdateNetwork(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateNetwork", testupdateNetwork)
 
@@ -340,10 +367,13 @@ func TestNetworkService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Network.NewUpdateNetworkServiceProviderParams("id")
-               _, err := client.Network.UpdateNetworkServiceProvider(p)
+               r, err := client.Network.UpdateNetworkServiceProvider(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateNetworkServiceProvider", testupdateNetworkServiceProvider)
 
@@ -352,10 +382,13 @@ func TestNetworkService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Network.NewUpdatePhysicalNetworkParams("id")
-               _, err := client.Network.UpdatePhysicalNetwork(p)
+               r, err := client.Network.UpdatePhysicalNetwork(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdatePhysicalNetwork", testupdatePhysicalNetwork)
 
@@ -364,10 +397,13 @@ func TestNetworkService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Network.NewUpdateStorageNetworkIpRangeParams("id")
-               _, err := client.Network.UpdateStorageNetworkIpRange(p)
+               r, err := client.Network.UpdateStorageNetworkIpRange(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateStorageNetworkIpRange", testupdateStorageNetworkIpRange)
 
diff --git a/test/NicService_test.go b/test/NicService_test.go
index 67caa28..e61039c 100644
--- a/test/NicService_test.go
+++ b/test/NicService_test.go
@@ -40,10 +40,13 @@ func TestNicService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Nic.NewAddIpToNicParams("nicid")
-               _, err := client.Nic.AddIpToNic(p)
+               r, err := client.Nic.AddIpToNic(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddIpToNic", testaddIpToNic)
 
@@ -76,10 +79,13 @@ func TestNicService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Nic.NewUpdateVmNicIpParams("nicid")
-               _, err := client.Nic.UpdateVmNicIp(p)
+               r, err := client.Nic.UpdateVmNicIp(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateVmNicIp", testupdateVmNicIp)
 
diff --git a/test/OvsElementService_test.go b/test/OvsElementService_test.go
index 3172247..485afb4 100644
--- a/test/OvsElementService_test.go
+++ b/test/OvsElementService_test.go
@@ -40,10 +40,13 @@ func TestOvsElementService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.OvsElement.NewConfigureOvsElementParams(true, "id")
-               _, err := client.OvsElement.ConfigureOvsElement(p)
+               r, err := client.OvsElement.ConfigureOvsElement(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ConfigureOvsElement", testconfigureOvsElement)
 
diff --git a/test/PodService_test.go b/test/PodService_test.go
index ab461e0..56b923a 100644
--- a/test/PodService_test.go
+++ b/test/PodService_test.go
@@ -40,10 +40,13 @@ func TestPodService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Pod.NewCreatePodParams("gateway", "name", 
"netmask", "startip", "zoneid")
-               _, err := client.Pod.CreatePod(p)
+               r, err := client.Pod.CreatePod(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreatePod", testcreatePod)
 
@@ -52,10 +55,13 @@ func TestPodService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Pod.NewDedicatePodParams("domainid", "podid")
-               _, err := client.Pod.DedicatePod(p)
+               r, err := client.Pod.DedicatePod(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DedicatePod", testdedicatePod)
 
@@ -112,10 +118,13 @@ func TestPodService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Pod.NewUpdatePodParams("id")
-               _, err := client.Pod.UpdatePod(p)
+               r, err := client.Pod.UpdatePod(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdatePod", testupdatePod)
 
diff --git a/test/PoolService_test.go b/test/PoolService_test.go
index cde6f06..8d2337e 100644
--- a/test/PoolService_test.go
+++ b/test/PoolService_test.go
@@ -40,10 +40,13 @@ func TestPoolService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Pool.NewCreateStoragePoolParams("name", "url", 
"zoneid")
-               _, err := client.Pool.CreateStoragePool(p)
+               r, err := client.Pool.CreateStoragePool(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateStoragePool", testcreateStoragePool)
 
@@ -64,10 +67,13 @@ func TestPoolService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Pool.NewFindStoragePoolsForMigrationParams("id")
-               _, err := client.Pool.FindStoragePoolsForMigration(p)
+               r, err := client.Pool.FindStoragePoolsForMigration(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("FindStoragePoolsForMigration", testfindStoragePoolsForMigration)
 
@@ -88,10 +94,13 @@ func TestPoolService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Pool.NewSyncStoragePoolParams("id")
-               _, err := client.Pool.SyncStoragePool(p)
+               r, err := client.Pool.SyncStoragePool(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("SyncStoragePool", testsyncStoragePool)
 
@@ -100,10 +109,13 @@ func TestPoolService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Pool.NewUpdateStoragePoolParams("id")
-               _, err := client.Pool.UpdateStoragePool(p)
+               r, err := client.Pool.UpdateStoragePool(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateStoragePool", testupdateStoragePool)
 
diff --git a/test/PortableIPService_test.go b/test/PortableIPService_test.go
index aafcdf0..c1001fa 100644
--- a/test/PortableIPService_test.go
+++ b/test/PortableIPService_test.go
@@ -40,10 +40,13 @@ func TestPortableIPService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.PortableIP.NewCreatePortableIpRangeParams("endip", 
"gateway", "netmask", 0, "startip")
-               _, err := client.PortableIP.CreatePortableIpRange(p)
+               r, err := client.PortableIP.CreatePortableIpRange(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreatePortableIpRange", testcreatePortableIpRange)
 
diff --git a/test/ProjectService_test.go b/test/ProjectService_test.go
index 3133edc..be48b6b 100644
--- a/test/ProjectService_test.go
+++ b/test/ProjectService_test.go
@@ -40,10 +40,13 @@ func TestProjectService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Project.NewActivateProjectParams("id")
-               _, err := client.Project.ActivateProject(p)
+               r, err := client.Project.ActivateProject(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ActivateProject", testactivateProject)
 
@@ -76,10 +79,13 @@ func TestProjectService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Project.NewCreateProjectParams("displaytext", 
"name")
-               _, err := client.Project.CreateProject(p)
+               r, err := client.Project.CreateProject(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateProject", testcreateProject)
 
@@ -160,10 +166,13 @@ func TestProjectService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Project.NewSuspendProjectParams("id")
-               _, err := client.Project.SuspendProject(p)
+               r, err := client.Project.SuspendProject(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("SuspendProject", testsuspendProject)
 
@@ -172,10 +181,13 @@ func TestProjectService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Project.NewUpdateProjectParams("id")
-               _, err := client.Project.UpdateProject(p)
+               r, err := client.Project.UpdateProject(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateProject", testupdateProject)
 
@@ -208,10 +220,13 @@ func TestProjectService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Project.NewCreateProjectRolePermissionParams("permission", "projectid", 
"projectroleid", "rule")
-               _, err := client.Project.CreateProjectRolePermission(p)
+               r, err := client.Project.CreateProjectRolePermission(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateProjectRolePermission", testcreateProjectRolePermission)
 
diff --git a/test/RoleService_test.go b/test/RoleService_test.go
index 360400d..6ec14ad 100644
--- a/test/RoleService_test.go
+++ b/test/RoleService_test.go
@@ -40,10 +40,13 @@ func TestRoleService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Role.NewCreateRoleParams("name")
-               _, err := client.Role.CreateRole(p)
+               r, err := client.Role.CreateRole(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateRole", testcreateRole)
 
@@ -52,10 +55,13 @@ func TestRoleService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Role.NewCreateRolePermissionParams("permission", 
"roleid", "rule")
-               _, err := client.Role.CreateRolePermission(p)
+               r, err := client.Role.CreateRolePermission(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateRolePermission", testcreateRolePermission)
 
@@ -88,10 +94,13 @@ func TestRoleService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Role.NewImportRoleParams("name", 
map[string]string{})
-               _, err := client.Role.ImportRole(p)
+               r, err := client.Role.ImportRole(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ImportRole", testimportRole)
 
@@ -124,10 +133,13 @@ func TestRoleService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Role.NewUpdateRoleParams("id")
-               _, err := client.Role.UpdateRole(p)
+               r, err := client.Role.UpdateRole(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateRole", testupdateRole)
 
diff --git a/test/RouterService_test.go b/test/RouterService_test.go
index cf3e7cb..7557c41 100644
--- a/test/RouterService_test.go
+++ b/test/RouterService_test.go
@@ -40,10 +40,13 @@ func TestRouterService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Router.NewChangeServiceForRouterParams("id", 
"serviceofferingid")
-               _, err := client.Router.ChangeServiceForRouter(p)
+               r, err := client.Router.ChangeServiceForRouter(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ChangeServiceForRouter", testchangeServiceForRouter)
 
@@ -52,10 +55,13 @@ func TestRouterService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Router.NewConfigureVirtualRouterElementParams(true, 
"id")
-               _, err := client.Router.ConfigureVirtualRouterElement(p)
+               r, err := client.Router.ConfigureVirtualRouterElement(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ConfigureVirtualRouterElement", 
testconfigureVirtualRouterElement)
 
@@ -64,10 +70,13 @@ func TestRouterService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Router.NewCreateVirtualRouterElementParams("nspid")
-               _, err := client.Router.CreateVirtualRouterElement(p)
+               r, err := client.Router.CreateVirtualRouterElement(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateVirtualRouterElement", testcreateVirtualRouterElement)
 
@@ -76,10 +85,13 @@ func TestRouterService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Router.NewDestroyRouterParams("id")
-               _, err := client.Router.DestroyRouter(p)
+               r, err := client.Router.DestroyRouter(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DestroyRouter", testdestroyRouter)
 
@@ -112,10 +124,13 @@ func TestRouterService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Router.NewRebootRouterParams("id")
-               _, err := client.Router.RebootRouter(p)
+               r, err := client.Router.RebootRouter(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("RebootRouter", testrebootRouter)
 
@@ -124,10 +139,13 @@ func TestRouterService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Router.NewStartRouterParams("id")
-               _, err := client.Router.StartRouter(p)
+               r, err := client.Router.StartRouter(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("StartRouter", teststartRouter)
 
@@ -136,10 +154,13 @@ func TestRouterService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Router.NewStopRouterParams("id")
-               _, err := client.Router.StopRouter(p)
+               r, err := client.Router.StopRouter(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("StopRouter", teststopRouter)
 
diff --git a/test/SSHService_test.go b/test/SSHService_test.go
index e402656..5995106 100644
--- a/test/SSHService_test.go
+++ b/test/SSHService_test.go
@@ -40,10 +40,13 @@ func TestSSHService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.SSH.NewCreateSSHKeyPairParams("name")
-               _, err := client.SSH.CreateSSHKeyPair(p)
+               r, err := client.SSH.CreateSSHKeyPair(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateSSHKeyPair", testcreateSSHKeyPair)
 
@@ -76,10 +79,13 @@ func TestSSHService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.SSH.NewRegisterSSHKeyPairParams("name", "publickey")
-               _, err := client.SSH.RegisterSSHKeyPair(p)
+               r, err := client.SSH.RegisterSSHKeyPair(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("RegisterSSHKeyPair", testregisterSSHKeyPair)
 
@@ -88,10 +94,13 @@ func TestSSHService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.SSH.NewResetSSHKeyForVirtualMachineParams("id", 
"keypair")
-               _, err := client.SSH.ResetSSHKeyForVirtualMachine(p)
+               r, err := client.SSH.ResetSSHKeyForVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ResetSSHKeyForVirtualMachine", testresetSSHKeyForVirtualMachine)
 
diff --git a/test/SecurityGroupService_test.go 
b/test/SecurityGroupService_test.go
index 55259d8..bd30cbf 100644
--- a/test/SecurityGroupService_test.go
+++ b/test/SecurityGroupService_test.go
@@ -64,10 +64,13 @@ func TestSecurityGroupService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.SecurityGroup.NewCreateSecurityGroupParams("name")
-               _, err := client.SecurityGroup.CreateSecurityGroup(p)
+               r, err := client.SecurityGroup.CreateSecurityGroup(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateSecurityGroup", testcreateSecurityGroup)
 
diff --git a/test/ServiceOfferingService_test.go 
b/test/ServiceOfferingService_test.go
index 7305541..b66c608 100644
--- a/test/ServiceOfferingService_test.go
+++ b/test/ServiceOfferingService_test.go
@@ -40,10 +40,13 @@ func TestServiceOfferingService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.ServiceOffering.NewCreateServiceOfferingParams("displaytext", "name")
-               _, err := client.ServiceOffering.CreateServiceOffering(p)
+               r, err := client.ServiceOffering.CreateServiceOffering(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateServiceOffering", testcreateServiceOffering)
 
@@ -76,10 +79,13 @@ func TestServiceOfferingService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.ServiceOffering.NewUpdateServiceOfferingParams("id")
-               _, err := client.ServiceOffering.UpdateServiceOffering(p)
+               r, err := client.ServiceOffering.UpdateServiceOffering(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateServiceOffering", testupdateServiceOffering)
 
diff --git a/test/SnapshotService_test.go b/test/SnapshotService_test.go
index 513c3ae..db6edc4 100644
--- a/test/SnapshotService_test.go
+++ b/test/SnapshotService_test.go
@@ -40,10 +40,13 @@ func TestSnapshotService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Snapshot.NewCreateSnapshotParams("volumeid")
-               _, err := client.Snapshot.CreateSnapshot(p)
+               r, err := client.Snapshot.CreateSnapshot(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateSnapshot", testcreateSnapshot)
 
@@ -52,10 +55,13 @@ func TestSnapshotService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Snapshot.NewCreateSnapshotPolicyParams("intervaltype", 0, "schedule", 
"timezone", "volumeid")
-               _, err := client.Snapshot.CreateSnapshotPolicy(p)
+               r, err := client.Snapshot.CreateSnapshotPolicy(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateSnapshotPolicy", testcreateSnapshotPolicy)
 
@@ -64,10 +70,13 @@ func TestSnapshotService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.Snapshot.NewCreateVMSnapshotParams("virtualmachineid")
-               _, err := client.Snapshot.CreateVMSnapshot(p)
+               r, err := client.Snapshot.CreateVMSnapshot(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateVMSnapshot", testcreateVMSnapshot)
 
@@ -148,10 +157,13 @@ func TestSnapshotService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Snapshot.NewRevertSnapshotParams("id")
-               _, err := client.Snapshot.RevertSnapshot(p)
+               r, err := client.Snapshot.RevertSnapshot(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("RevertSnapshot", testrevertSnapshot)
 
@@ -160,10 +172,13 @@ func TestSnapshotService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Snapshot.NewRevertToVMSnapshotParams("vmsnapshotid")
-               _, err := client.Snapshot.RevertToVMSnapshot(p)
+               r, err := client.Snapshot.RevertToVMSnapshot(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("RevertToVMSnapshot", testrevertToVMSnapshot)
 
@@ -172,10 +187,13 @@ func TestSnapshotService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Snapshot.NewUpdateSnapshotPolicyParams()
-               _, err := client.Snapshot.UpdateSnapshotPolicy(p)
+               r, err := client.Snapshot.UpdateSnapshotPolicy(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateSnapshotPolicy", testupdateSnapshotPolicy)
 
diff --git a/test/StoragePoolService_test.go b/test/StoragePoolService_test.go
index 364c153..439ca0a 100644
--- a/test/StoragePoolService_test.go
+++ b/test/StoragePoolService_test.go
@@ -40,10 +40,13 @@ func TestStoragePoolService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.StoragePool.NewCancelStorageMaintenanceParams("id")
-               _, err := client.StoragePool.CancelStorageMaintenance(p)
+               r, err := client.StoragePool.CancelStorageMaintenance(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CancelStorageMaintenance", testcancelStorageMaintenance)
 
@@ -52,10 +55,13 @@ func TestStoragePoolService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.StoragePool.NewEnableStorageMaintenanceParams("id")
-               _, err := client.StoragePool.EnableStorageMaintenance(p)
+               r, err := client.StoragePool.EnableStorageMaintenance(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("EnableStorageMaintenance", testenableStorageMaintenance)
 
diff --git a/test/SwiftService_test.go b/test/SwiftService_test.go
index 5c7bceb..b2fd697 100644
--- a/test/SwiftService_test.go
+++ b/test/SwiftService_test.go
@@ -40,10 +40,13 @@ func TestSwiftService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Swift.NewAddSwiftParams("url")
-               _, err := client.Swift.AddSwift(p)
+               r, err := client.Swift.AddSwift(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddSwift", testaddSwift)
 
diff --git a/test/SystemVMService_test.go b/test/SystemVMService_test.go
index 587efcc..480789b 100644
--- a/test/SystemVMService_test.go
+++ b/test/SystemVMService_test.go
@@ -40,10 +40,13 @@ func TestSystemVMService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.SystemVM.NewChangeServiceForSystemVmParams("id", 
"serviceofferingid")
-               _, err := client.SystemVM.ChangeServiceForSystemVm(p)
+               r, err := client.SystemVM.ChangeServiceForSystemVm(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ChangeServiceForSystemVm", testchangeServiceForSystemVm)
 
@@ -52,10 +55,13 @@ func TestSystemVMService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.SystemVM.NewDestroySystemVmParams("id")
-               _, err := client.SystemVM.DestroySystemVm(p)
+               r, err := client.SystemVM.DestroySystemVm(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DestroySystemVm", testdestroySystemVm)
 
@@ -76,10 +82,13 @@ func TestSystemVMService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.SystemVM.NewMigrateSystemVmParams("virtualmachineid")
-               _, err := client.SystemVM.MigrateSystemVm(p)
+               r, err := client.SystemVM.MigrateSystemVm(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("MigrateSystemVm", testmigrateSystemVm)
 
@@ -88,10 +97,13 @@ func TestSystemVMService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.SystemVM.NewRebootSystemVmParams("id")
-               _, err := client.SystemVM.RebootSystemVm(p)
+               r, err := client.SystemVM.RebootSystemVm(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("RebootSystemVm", testrebootSystemVm)
 
@@ -100,10 +112,13 @@ func TestSystemVMService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.SystemVM.NewScaleSystemVmParams("id", 
"serviceofferingid")
-               _, err := client.SystemVM.ScaleSystemVm(p)
+               r, err := client.SystemVM.ScaleSystemVm(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ScaleSystemVm", testscaleSystemVm)
 
@@ -112,10 +127,13 @@ func TestSystemVMService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.SystemVM.NewStartSystemVmParams("id")
-               _, err := client.SystemVM.StartSystemVm(p)
+               r, err := client.SystemVM.StartSystemVm(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("StartSystemVm", teststartSystemVm)
 
@@ -124,10 +142,13 @@ func TestSystemVMService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.SystemVM.NewStopSystemVmParams("id")
-               _, err := client.SystemVM.StopSystemVm(p)
+               r, err := client.SystemVM.StopSystemVm(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("StopSystemVm", teststopSystemVm)
 
diff --git a/test/TemplateService_test.go b/test/TemplateService_test.go
index ea4035d..cacd61f 100644
--- a/test/TemplateService_test.go
+++ b/test/TemplateService_test.go
@@ -40,10 +40,13 @@ func TestTemplateService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Template.NewCopyTemplateParams("id")
-               _, err := client.Template.CopyTemplate(p)
+               r, err := client.Template.CopyTemplate(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CopyTemplate", testcopyTemplate)
 
@@ -52,10 +55,13 @@ func TestTemplateService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Template.NewCreateTemplateParams("displaytext", 
"name", "ostypeid")
-               _, err := client.Template.CreateTemplate(p)
+               r, err := client.Template.CreateTemplate(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateTemplate", testcreateTemplate)
 
@@ -76,10 +82,13 @@ func TestTemplateService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Template.NewExtractTemplateParams("id", "mode")
-               _, err := client.Template.ExtractTemplate(p)
+               r, err := client.Template.ExtractTemplate(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ExtractTemplate", testextractTemplate)
 
@@ -124,10 +133,13 @@ func TestTemplateService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Template.NewPrepareTemplateParams("templateid", 
"zoneid")
-               _, err := client.Template.PrepareTemplate(p)
+               r, err := client.Template.PrepareTemplate(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("PrepareTemplate", testprepareTemplate)
 
@@ -148,10 +160,13 @@ func TestTemplateService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Template.NewUpdateTemplateParams("id")
-               _, err := client.Template.UpdateTemplate(p)
+               r, err := client.Template.UpdateTemplate(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateTemplate", testupdateTemplate)
 
diff --git a/test/UCSService_test.go b/test/UCSService_test.go
index 46108f2..9df5d66 100644
--- a/test/UCSService_test.go
+++ b/test/UCSService_test.go
@@ -40,10 +40,13 @@ func TestUCSService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.UCS.NewAddUcsManagerParams("password", "url", 
"username", "zoneid")
-               _, err := client.UCS.AddUcsManager(p)
+               r, err := client.UCS.AddUcsManager(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddUcsManager", testaddUcsManager)
 
@@ -52,10 +55,13 @@ func TestUCSService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.UCS.NewAssociateUcsProfileToBladeParams("bladeid", 
"profiledn", "ucsmanagerid")
-               _, err := client.UCS.AssociateUcsProfileToBlade(p)
+               r, err := client.UCS.AssociateUcsProfileToBlade(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AssociateUcsProfileToBlade", testassociateUcsProfileToBlade)
 
diff --git a/test/UsageService_test.go b/test/UsageService_test.go
index 012dc52..992ce02 100644
--- a/test/UsageService_test.go
+++ b/test/UsageService_test.go
@@ -40,10 +40,13 @@ func TestUsageService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Usage.NewAddTrafficMonitorParams("url", "zoneid")
-               _, err := client.Usage.AddTrafficMonitor(p)
+               r, err := client.Usage.AddTrafficMonitor(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddTrafficMonitor", testaddTrafficMonitor)
 
@@ -52,10 +55,13 @@ func TestUsageService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Usage.NewAddTrafficTypeParams("physicalnetworkid", 
"traffictype")
-               _, err := client.Usage.AddTrafficType(p)
+               r, err := client.Usage.AddTrafficType(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddTrafficType", testaddTrafficType)
 
@@ -172,10 +178,13 @@ func TestUsageService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Usage.NewUpdateTrafficTypeParams("id")
-               _, err := client.Usage.UpdateTrafficType(p)
+               r, err := client.Usage.UpdateTrafficType(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateTrafficType", testupdateTrafficType)
 
diff --git a/test/UserService_test.go b/test/UserService_test.go
index f5579a9..4ec0cba 100644
--- a/test/UserService_test.go
+++ b/test/UserService_test.go
@@ -40,10 +40,13 @@ func TestUserService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.User.NewCreateUserParams("account", "email", 
"firstname", "lastname", "password", "username")
-               _, err := client.User.CreateUser(p)
+               r, err := client.User.CreateUser(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateUser", testcreateUser)
 
@@ -64,10 +67,13 @@ func TestUserService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.User.NewDisableUserParams("id")
-               _, err := client.User.DisableUser(p)
+               r, err := client.User.DisableUser(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DisableUser", testdisableUser)
 
@@ -76,10 +82,13 @@ func TestUserService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.User.NewEnableUserParams("id")
-               _, err := client.User.EnableUser(p)
+               r, err := client.User.EnableUser(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("EnableUser", testenableUser)
 
@@ -88,10 +97,13 @@ func TestUserService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.User.NewGetUserParams("userapikey")
-               _, err := client.User.GetUser(p)
+               r, err := client.User.GetUser(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("GetUser", testgetUser)
 
@@ -136,10 +148,13 @@ func TestUserService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.User.NewLockUserParams("id")
-               _, err := client.User.LockUser(p)
+               r, err := client.User.LockUser(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("LockUser", testlockUser)
 
@@ -160,10 +175,13 @@ func TestUserService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.User.NewUpdateUserParams("id")
-               _, err := client.User.UpdateUser(p)
+               r, err := client.User.UpdateUser(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateUser", testupdateUser)
 
diff --git a/test/VLANService_test.go b/test/VLANService_test.go
index ca58ac7..e7b1bfe 100644
--- a/test/VLANService_test.go
+++ b/test/VLANService_test.go
@@ -40,10 +40,13 @@ func TestVLANService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VLAN.NewCreateVlanIpRangeParams()
-               _, err := client.VLAN.CreateVlanIpRange(p)
+               r, err := client.VLAN.CreateVlanIpRange(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateVlanIpRange", testcreateVlanIpRange)
 
@@ -52,10 +55,13 @@ func TestVLANService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.VLAN.NewDedicateGuestVlanRangeParams("physicalnetworkid", "vlanrange")
-               _, err := client.VLAN.DedicateGuestVlanRange(p)
+               r, err := client.VLAN.DedicateGuestVlanRange(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DedicateGuestVlanRange", testdedicateGuestVlanRange)
 
diff --git a/test/VMGroupService_test.go b/test/VMGroupService_test.go
index 3382f5c..711b178 100644
--- a/test/VMGroupService_test.go
+++ b/test/VMGroupService_test.go
@@ -40,10 +40,13 @@ func TestVMGroupService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VMGroup.NewCreateInstanceGroupParams("name")
-               _, err := client.VMGroup.CreateInstanceGroup(p)
+               r, err := client.VMGroup.CreateInstanceGroup(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateInstanceGroup", testcreateInstanceGroup)
 
@@ -76,10 +79,13 @@ func TestVMGroupService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VMGroup.NewUpdateInstanceGroupParams("id")
-               _, err := client.VMGroup.UpdateInstanceGroup(p)
+               r, err := client.VMGroup.UpdateInstanceGroup(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateInstanceGroup", testupdateInstanceGroup)
 
diff --git a/test/VPCService_test.go b/test/VPCService_test.go
index 782c9de..511e20d 100644
--- a/test/VPCService_test.go
+++ b/test/VPCService_test.go
@@ -40,10 +40,13 @@ func TestVPCService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VPC.NewCreatePrivateGatewayParams("gateway", 
"ipaddress", "netmask", "vlan", "vpcid")
-               _, err := client.VPC.CreatePrivateGateway(p)
+               r, err := client.VPC.CreatePrivateGateway(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreatePrivateGateway", testcreatePrivateGateway)
 
@@ -52,10 +55,13 @@ func TestVPCService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VPC.NewCreateStaticRouteParams("cidr", "gatewayid")
-               _, err := client.VPC.CreateStaticRoute(p)
+               r, err := client.VPC.CreateStaticRoute(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateStaticRoute", testcreateStaticRoute)
 
@@ -64,10 +70,13 @@ func TestVPCService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VPC.NewCreateVPCParams("cidr", "displaytext", 
"name", "vpcofferingid", "zoneid")
-               _, err := client.VPC.CreateVPC(p)
+               r, err := client.VPC.CreateVPC(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateVPC", testcreateVPC)
 
@@ -76,10 +85,13 @@ func TestVPCService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VPC.NewCreateVPCOfferingParams("displaytext", 
"name", []string{})
-               _, err := client.VPC.CreateVPCOffering(p)
+               r, err := client.VPC.CreateVPCOffering(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateVPCOffering", testcreateVPCOffering)
 
@@ -196,10 +208,13 @@ func TestVPCService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VPC.NewUpdateVPCParams("id")
-               _, err := client.VPC.UpdateVPC(p)
+               r, err := client.VPC.UpdateVPC(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateVPC", testupdateVPC)
 
@@ -208,10 +223,13 @@ func TestVPCService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VPC.NewUpdateVPCOfferingParams("id")
-               _, err := client.VPC.UpdateVPCOffering(p)
+               r, err := client.VPC.UpdateVPCOffering(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateVPCOffering", testupdateVPCOffering)
 
diff --git a/test/VPNService_test.go b/test/VPNService_test.go
index ae7d0bb..20cb349 100644
--- a/test/VPNService_test.go
+++ b/test/VPNService_test.go
@@ -40,10 +40,13 @@ func TestVPNService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VPN.NewAddVpnUserParams("password", "username")
-               _, err := client.VPN.AddVpnUser(p)
+               r, err := client.VPN.AddVpnUser(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddVpnUser", testaddVpnUser)
 
@@ -52,10 +55,13 @@ func TestVPNService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VPN.NewCreateRemoteAccessVpnParams("publicipid")
-               _, err := client.VPN.CreateRemoteAccessVpn(p)
+               r, err := client.VPN.CreateRemoteAccessVpn(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateRemoteAccessVpn", testcreateRemoteAccessVpn)
 
@@ -64,10 +70,13 @@ func TestVPNService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.VPN.NewCreateVpnConnectionParams("s2scustomergatewayid", 
"s2svpngatewayid")
-               _, err := client.VPN.CreateVpnConnection(p)
+               r, err := client.VPN.CreateVpnConnection(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateVpnConnection", testcreateVpnConnection)
 
@@ -76,10 +85,13 @@ func TestVPNService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VPN.NewCreateVpnCustomerGatewayParams("cidrlist", 
"esppolicy", "gateway", "ikepolicy", "ipsecpsk")
-               _, err := client.VPN.CreateVpnCustomerGateway(p)
+               r, err := client.VPN.CreateVpnCustomerGateway(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateVpnCustomerGateway", testcreateVpnCustomerGateway)
 
@@ -88,10 +100,13 @@ func TestVPNService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VPN.NewCreateVpnGatewayParams("vpcid")
-               _, err := client.VPN.CreateVpnGateway(p)
+               r, err := client.VPN.CreateVpnGateway(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateVpnGateway", testcreateVpnGateway)
 
@@ -220,10 +235,13 @@ func TestVPNService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VPN.NewResetVpnConnectionParams("id")
-               _, err := client.VPN.ResetVpnConnection(p)
+               r, err := client.VPN.ResetVpnConnection(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ResetVpnConnection", testresetVpnConnection)
 
@@ -232,10 +250,13 @@ func TestVPNService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VPN.NewUpdateRemoteAccessVpnParams("id")
-               _, err := client.VPN.UpdateRemoteAccessVpn(p)
+               r, err := client.VPN.UpdateRemoteAccessVpn(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateRemoteAccessVpn", testupdateRemoteAccessVpn)
 
@@ -244,10 +265,13 @@ func TestVPNService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VPN.NewUpdateVpnConnectionParams("id")
-               _, err := client.VPN.UpdateVpnConnection(p)
+               r, err := client.VPN.UpdateVpnConnection(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateVpnConnection", testupdateVpnConnection)
 
@@ -256,10 +280,13 @@ func TestVPNService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VPN.NewUpdateVpnCustomerGatewayParams("cidrlist", 
"esppolicy", "gateway", "id", "ikepolicy", "ipsecpsk")
-               _, err := client.VPN.UpdateVpnCustomerGateway(p)
+               r, err := client.VPN.UpdateVpnCustomerGateway(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateVpnCustomerGateway", testupdateVpnCustomerGateway)
 
@@ -268,10 +295,13 @@ func TestVPNService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VPN.NewUpdateVpnGatewayParams("id")
-               _, err := client.VPN.UpdateVpnGateway(p)
+               r, err := client.VPN.UpdateVpnGateway(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateVpnGateway", testupdateVpnGateway)
 
diff --git a/test/VirtualMachineService_test.go 
b/test/VirtualMachineService_test.go
index 71822e7..4a8785f 100644
--- a/test/VirtualMachineService_test.go
+++ b/test/VirtualMachineService_test.go
@@ -40,10 +40,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.VirtualMachine.NewAddNicToVirtualMachineParams("networkid", 
"virtualmachineid")
-               _, err := client.VirtualMachine.AddNicToVirtualMachine(p)
+               r, err := client.VirtualMachine.AddNicToVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AddNicToVirtualMachine", testaddNicToVirtualMachine)
 
@@ -52,10 +55,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.VirtualMachine.NewAssignVirtualMachineParams("virtualmachineid")
-               _, err := client.VirtualMachine.AssignVirtualMachine(p)
+               r, err := client.VirtualMachine.AssignVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AssignVirtualMachine", testassignVirtualMachine)
 
@@ -64,10 +70,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.VirtualMachine.NewChangeServiceForVirtualMachineParams("id", 
"serviceofferingid")
-               _, err := 
client.VirtualMachine.ChangeServiceForVirtualMachine(p)
+               r, err := 
client.VirtualMachine.ChangeServiceForVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ChangeServiceForVirtualMachine", 
testchangeServiceForVirtualMachine)
 
@@ -88,10 +97,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.VirtualMachine.NewDeployVirtualMachineParams("serviceofferingid", 
"templateid", "zoneid")
-               _, err := client.VirtualMachine.DeployVirtualMachine(p)
+               r, err := client.VirtualMachine.DeployVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DeployVirtualMachine", testdeployVirtualMachine)
 
@@ -100,10 +112,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VirtualMachine.NewDestroyVirtualMachineParams("id")
-               _, err := client.VirtualMachine.DestroyVirtualMachine(p)
+               r, err := client.VirtualMachine.DestroyVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DestroyVirtualMachine", testdestroyVirtualMachine)
 
@@ -160,10 +175,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.VirtualMachine.NewMigrateVirtualMachineParams("virtualmachineid")
-               _, err := client.VirtualMachine.MigrateVirtualMachine(p)
+               r, err := client.VirtualMachine.MigrateVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("MigrateVirtualMachine", testmigrateVirtualMachine)
 
@@ -172,10 +190,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.VirtualMachine.NewMigrateVirtualMachineWithVolumeParams("virtualmachineid")
-               _, err := 
client.VirtualMachine.MigrateVirtualMachineWithVolume(p)
+               r, err := 
client.VirtualMachine.MigrateVirtualMachineWithVolume(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("MigrateVirtualMachineWithVolume", 
testmigrateVirtualMachineWithVolume)
 
@@ -184,10 +205,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VirtualMachine.NewRebootVirtualMachineParams("id")
-               _, err := client.VirtualMachine.RebootVirtualMachine(p)
+               r, err := client.VirtualMachine.RebootVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("RebootVirtualMachine", testrebootVirtualMachine)
 
@@ -196,10 +220,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VirtualMachine.NewRecoverVirtualMachineParams("id")
-               _, err := client.VirtualMachine.RecoverVirtualMachine(p)
+               r, err := client.VirtualMachine.RecoverVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("RecoverVirtualMachine", testrecoverVirtualMachine)
 
@@ -208,10 +235,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.VirtualMachine.NewRemoveNicFromVirtualMachineParams("nicid", 
"virtualmachineid")
-               _, err := client.VirtualMachine.RemoveNicFromVirtualMachine(p)
+               r, err := client.VirtualMachine.RemoveNicFromVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("RemoveNicFromVirtualMachine", testremoveNicFromVirtualMachine)
 
@@ -220,10 +250,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.VirtualMachine.NewResetPasswordForVirtualMachineParams("id")
-               _, err := 
client.VirtualMachine.ResetPasswordForVirtualMachine(p)
+               r, err := 
client.VirtualMachine.ResetPasswordForVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ResetPasswordForVirtualMachine", 
testresetPasswordForVirtualMachine)
 
@@ -232,10 +265,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.VirtualMachine.NewRestoreVirtualMachineParams("virtualmachineid")
-               _, err := client.VirtualMachine.RestoreVirtualMachine(p)
+               r, err := client.VirtualMachine.RestoreVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("RestoreVirtualMachine", testrestoreVirtualMachine)
 
@@ -256,10 +292,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VirtualMachine.NewStartVirtualMachineParams("id")
-               _, err := client.VirtualMachine.StartVirtualMachine(p)
+               r, err := client.VirtualMachine.StartVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("StartVirtualMachine", teststartVirtualMachine)
 
@@ -268,10 +307,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VirtualMachine.NewStopVirtualMachineParams("id")
-               _, err := client.VirtualMachine.StopVirtualMachine(p)
+               r, err := client.VirtualMachine.StopVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("StopVirtualMachine", teststopVirtualMachine)
 
@@ -280,10 +322,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := 
client.VirtualMachine.NewUpdateDefaultNicForVirtualMachineParams("nicid", 
"virtualmachineid")
-               _, err := 
client.VirtualMachine.UpdateDefaultNicForVirtualMachine(p)
+               r, err := 
client.VirtualMachine.UpdateDefaultNicForVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateDefaultNicForVirtualMachine", 
testupdateDefaultNicForVirtualMachine)
 
@@ -292,10 +337,13 @@ func TestVirtualMachineService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.VirtualMachine.NewUpdateVirtualMachineParams("id")
-               _, err := client.VirtualMachine.UpdateVirtualMachine(p)
+               r, err := client.VirtualMachine.UpdateVirtualMachine(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateVirtualMachine", testupdateVirtualMachine)
 
diff --git a/test/VolumeService_test.go b/test/VolumeService_test.go
index 239cb53..1869db2 100644
--- a/test/VolumeService_test.go
+++ b/test/VolumeService_test.go
@@ -40,10 +40,13 @@ func TestVolumeService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Volume.NewAttachVolumeParams("id", 
"virtualmachineid")
-               _, err := client.Volume.AttachVolume(p)
+               r, err := client.Volume.AttachVolume(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("AttachVolume", testattachVolume)
 
@@ -52,10 +55,13 @@ func TestVolumeService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Volume.NewCreateVolumeParams()
-               _, err := client.Volume.CreateVolume(p)
+               r, err := client.Volume.CreateVolume(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateVolume", testcreateVolume)
 
@@ -76,10 +82,13 @@ func TestVolumeService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Volume.NewDestroyVolumeParams("id")
-               _, err := client.Volume.DestroyVolume(p)
+               r, err := client.Volume.DestroyVolume(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DestroyVolume", testdestroyVolume)
 
@@ -88,10 +97,13 @@ func TestVolumeService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Volume.NewDetachVolumeParams()
-               _, err := client.Volume.DetachVolume(p)
+               r, err := client.Volume.DetachVolume(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DetachVolume", testdetachVolume)
 
@@ -100,10 +112,13 @@ func TestVolumeService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Volume.NewExtractVolumeParams("id", "mode", 
"zoneid")
-               _, err := client.Volume.ExtractVolume(p)
+               r, err := client.Volume.ExtractVolume(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ExtractVolume", testextractVolume)
 
@@ -184,10 +199,13 @@ func TestVolumeService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Volume.NewMigrateVolumeParams("storageid", 
"volumeid")
-               _, err := client.Volume.MigrateVolume(p)
+               r, err := client.Volume.MigrateVolume(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("MigrateVolume", testmigrateVolume)
 
@@ -196,10 +214,13 @@ func TestVolumeService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Volume.NewRecoverVolumeParams("id")
-               _, err := client.Volume.RecoverVolume(p)
+               r, err := client.Volume.RecoverVolume(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("RecoverVolume", testrecoverVolume)
 
@@ -208,10 +229,13 @@ func TestVolumeService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Volume.NewResizeVolumeParams("id")
-               _, err := client.Volume.ResizeVolume(p)
+               r, err := client.Volume.ResizeVolume(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("ResizeVolume", testresizeVolume)
 
@@ -220,10 +244,13 @@ func TestVolumeService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Volume.NewUpdateVolumeParams()
-               _, err := client.Volume.UpdateVolume(p)
+               r, err := client.Volume.UpdateVolume(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateVolume", testupdateVolume)
 
@@ -232,10 +259,13 @@ func TestVolumeService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Volume.NewUploadVolumeParams("format", "name", 
"url", "zoneid")
-               _, err := client.Volume.UploadVolume(p)
+               r, err := client.Volume.UploadVolume(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UploadVolume", testuploadVolume)
 
diff --git a/test/ZoneService_test.go b/test/ZoneService_test.go
index 15b2727..8cbb310 100644
--- a/test/ZoneService_test.go
+++ b/test/ZoneService_test.go
@@ -40,10 +40,13 @@ func TestZoneService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Zone.NewCreateZoneParams("dns1", "internaldns1", 
"name", "networktype")
-               _, err := client.Zone.CreateZone(p)
+               r, err := client.Zone.CreateZone(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("CreateZone", testcreateZone)
 
@@ -52,10 +55,13 @@ func TestZoneService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Zone.NewDedicateZoneParams("domainid", "zoneid")
-               _, err := client.Zone.DedicateZone(p)
+               r, err := client.Zone.DedicateZone(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("DedicateZone", testdedicateZone)
 
@@ -172,10 +178,13 @@ func TestZoneService(t *testing.T) {
                        t.Skipf("Skipping as no json response is provided in 
testdata")
                }
                p := client.Zone.NewUpdateZoneParams("id")
-               _, err := client.Zone.UpdateZone(p)
+               r, err := client.Zone.UpdateZone(p)
                if err != nil {
                        t.Errorf(err.Error())
                }
+               if r.Id == "" {
+                       t.Errorf("Failed to parse response. ID not found")
+               }
        }
        t.Run("UpdateZone", testupdateZone)
 
diff --git a/test/testdata/SSHService.json b/test/testdata/SSHService.json
index ab3a1b0..5fcf3b1 100644
--- a/test/testdata/SSHService.json
+++ b/test/testdata/SSHService.json
@@ -2,6 +2,7 @@
   "createSSHKeyPair": {
     "createsshkeypairresponse": {
       "keypair": {
+        "id": "e4874e10-5fdf-11ea-9a56-1e006800018c",
         "privatekey": "-----BEGIN RSA PRIVATE 
KEY-----\nMIIEowIBAAKCAQEAlMDlCrzlmEBwmPmQBhvD4PeRdEUV2tyoEuLLwkg7FkZFrjdd\nZaC8+N82Jm/lr27sqq5xVoo6n54k3hG9HVxNZjQBY5IiRNeQIF30Ye5c6TzboCCH\nAJVZYf4Dj5ucJvxg+V1+rZMNNJs6y2tMRGfmQ9zdrHZwOutKBeWTlGLtXyMabc5o\nVVe4hjngxh7s+CbEAA8oE9KFk1ZyhJ7SDj6G9vrMoBYNgqNGG6DHF/NM0A0yaEnj\nZU5MECXnw9qT7W8ggy5UM9AYtfzAyWBrS3jDwFgOjEZ+TW7vvC1Q3lnGkzpTHlye\nRppPm/7Xa8xapIdDV2UdEXnChHj9+Jwpa5nBJQIDAQABAoIBABaReW56oD7MMAkV\ne+NhXQOJq/i+7oTpC1rqK83LFaPYf4PiBHqBu4nq
 [...]
         "name": "testSSHKey",
         "account": "admin",

Reply via email to