func TestReleaseFloatingIp(t *testing.T) { queuedTask := &photon.Task{ Operation: "RELEASE_FLOATING_IP", State: "QUEUED", ID: "fake-vm-task-ID", Entity: photon.Entity{ID: "fake_vm_ID"}, } completedTask := &photon.Task{ Operation: "RELEASE_FLOATING_IP", State: "COMPLETED", ID: "fake-vm-task-ID", Entity: photon.Entity{ID: "fake_vm_ID"}, } response, err := json.Marshal(queuedTask) if err != nil { t.Error("Not expecting error serializaing expected queuedTask") } taskResponse, err := json.Marshal(completedTask) if err != nil { t.Error("Not expecting error serializaing expected completedTask") } server := mocks.NewTestServer() mocks.RegisterResponder( "POST", server.URL+"/vms/"+"fake_vm_ID"+"/release_floating_ip", mocks.CreateResponder(200, string(response[:]))) mocks.RegisterResponder( "GET", server.URL+"/tasks/"+queuedTask.ID, mocks.CreateResponder(200, string(taskResponse[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) globalSet := flag.NewFlagSet("test", 0) globalSet.Bool("non-interactive", true, "doc") globalCtx := cli.NewContext(nil, globalSet, nil) err = globalSet.Parse([]string{"--non-interactive"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"fake_vm_ID"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } set.String("network_id", "fake_network_id", "network id") cxt := cli.NewContext(nil, set, globalCtx) err = releaseFloatingIp(cxt) if err != nil { t.Error("Not expecting error creating VM image: " + err.Error()) } }
func TestListDeploymentHosts(t *testing.T) { hostList := MockHostsPage{ Items: []photon.Host{ { Username: "******", Password: "******", Address: "testIP", Tags: []string{"CLOUD"}, ID: "host-test-id", State: "COMPLETED", }, }, NextPageLink: "/fake-next-page-link", PreviousPageLink: "", } response, err := json.Marshal(hostList) if err != nil { t.Error("Not expecting error serializing host list") } server := mocks.NewTestServer() mocks.RegisterResponder( "GET", server.URL+"/deployments/1/hosts", mocks.CreateResponder(200, string(response[:]))) hostList = MockHostsPage{ Items: []photon.Host{}, NextPageLink: "", PreviousPageLink: "", } response, err = json.Marshal(hostList) if err != nil { t.Error("Not expecting error serializing expected taskLists") } mocks.RegisterResponder( "GET", server.URL+"/fake-next-page-link", mocks.CreateResponder(200, string(response[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"1"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, nil) err = listDeploymentHosts(cxt) if err != nil { t.Error("Not expecting deployment list hosts to fail") } }
func TestResizeCluster(t *testing.T) { queuedTask := &photon.Task{ Operation: "RESIZE_CLUSTER", State: "QUEUED", ID: "fake_resize_cluster_task_id", Entity: photon.Entity{ID: "fake_cluster_id"}, } queuedTaskResponse, err := json.Marshal(queuedTask) if err != nil { t.Error("Not expecting error serializing expected queued task") } completedTask := &photon.Task{ Operation: "RESIZE_CLUSTER", State: "COMPLETED", ID: "fake_resize_cluster_task_id", Entity: photon.Entity{ID: "fake_cluster_id"}, } completedTaskResponse, err := json.Marshal(completedTask) if err != nil { t.Error("Not expecting error serializing expected completed task") } server := mocks.NewTestServer() defer server.Close() mocks.RegisterResponder( "POST", server.URL+"/clusters/fake_cluster_id/resize", mocks.CreateResponder(200, string(queuedTaskResponse[:]))) mocks.RegisterResponder( "GET", server.URL+"/tasks/fake_resize_cluster_task_id", mocks.CreateResponder(200, string(completedTaskResponse[:]))) mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) globalSet := flag.NewFlagSet("test", 0) globalSet.Bool("non-interactive", true, "doc") globalCtx := cli.NewContext(nil, globalSet, nil) err = globalSet.Parse([]string{"--non-interactive"}) if err != nil { t.Error("Not expecting argument parsing to fail") } set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"fake_cluster_id", "50"}) if err != nil { t.Error("Not expecting argument parsing to fail") } ctx := cli.NewContext(nil, set, globalCtx) err = resizeCluster(ctx, os.Stdout) if err != nil { t.Error("Not expecting error resizing cluster: " + err.Error()) } }
func TestEnableClusterType(t *testing.T) { deploymentId := "deployment1" queuedTask := &photon.Task{ Operation: "CONFIGURE_CLUSTER", State: "QUEUED", Entity: photon.Entity{ID: deploymentId}, } completedTask := &photon.Task{ Operation: "CONFIGURE_CLUSTER", State: "COMPLETED", Entity: photon.Entity{ID: deploymentId}, } response, err := json.Marshal(queuedTask) if err != nil { t.Error("Not expecting error during serializing expected queuedTask") } taskResponse, err := json.Marshal(completedTask) if err != nil { t.Error("Not expecting error during serializing expected completedTask") } server := mocks.NewTestServer() mocks.RegisterResponder( "POST", server.URL+"/deployments/"+deploymentId+"/enable_cluster_type", mocks.CreateResponder(200, string(response[:]))) mocks.RegisterResponder( "GET", server.URL+"/tasks/"+queuedTask.ID, mocks.CreateResponder(200, string(taskResponse[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) globalSet := flag.NewFlagSet("test", 0) globalSet.Bool("non-interactive", true, "doc") globalCtx := cli.NewContext(nil, globalSet, nil) err = globalSet.Parse([]string{"--non-interactive"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } set := flag.NewFlagSet("test", 0) err = set.Parse([]string{deploymentId}) if err != nil { t.Error("Not expecting arguments parsing to fail") } set.String("type", "SWARM", "Cluster type") set.String("image-id", "abcd", "image id") cxt := cli.NewContext(nil, set, globalCtx) err = enableClusterType(cxt) if err != nil { t.Error(err) t.Error("Not expecting deployment list hosts to fail") } }
func TestVMNetworks(t *testing.T) { queuedTask := &photon.Task{ Operation: "GET_NETWORKS", State: "COMPLETED", ID: "fake-vm-task-ID", Entity: photon.Entity{ID: "fake_vm_ID"}, } taskResponse, err := json.Marshal(queuedTask) if err != nil { t.Error("Not expecting error serializaing expected queuedTask") } networkMap := make(map[string]interface{}) networkMap["network"] = "VMmgmtNetwork" networkMap["macAddress"] = "00:0c:29:7a:b4:d5" networkMap["ipAddress"] = "10.144.121.12" networkMap["netmask"] = "255.255.252.0" networkMap["isConnected"] = "true" networkConnectionMap := make(map[string]interface{}) networkConnectionMap["networkConnections"] = []interface{}{networkMap} completedTask := &photon.Task{ Operation: "GET_NETWORKS", State: "COMPLETED", ResourceProperties: networkConnectionMap, } response, err := json.Marshal(completedTask) if err != nil { t.Error("Not expecting error serializaing expected completedTask") } server := mocks.NewTestServer() mocks.RegisterResponder( "GET", server.URL+"/vms/"+"fake_vm_ID"+"/subnets", mocks.CreateResponder(200, string(taskResponse[:]))) mocks.RegisterResponder( "GET", server.URL+"/tasks/"+queuedTask.ID, mocks.CreateResponder(200, string(response[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"fake_vm_ID"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, nil) err = listVMNetworks(cxt) if err != nil { t.Error("Not expecting error getting vm networks: " + err.Error()) } }
func TestSetDeploymentSecurityGroups(t *testing.T) { deploymentId := "deployment1" queuedTask := &photon.Task{ Operation: "UPDATE_DEPLOYMENT_SECURITY_GROUPS", State: "QUEUED", Entity: photon.Entity{ID: deploymentId}, } completedTask := &photon.Task{ Operation: "UPDATE_DEPLOYMENT_SECURITY_GROUPS", State: "COMPLETED", Entity: photon.Entity{ID: deploymentId}, } response, err := json.Marshal(queuedTask) if err != nil { t.Error("Not expecting error during serializing expected queuedTask") } taskResponse, err := json.Marshal(completedTask) if err != nil { t.Error("Not expecting error during serializing expected completedTask") } server := mocks.NewTestServer() mocks.RegisterResponder( "POST", server.URL+"/deployments/"+deploymentId+"/set_security_groups", mocks.CreateResponder(200, string(response[:]))) mocks.RegisterResponder( "GET", server.URL+"/tasks/"+queuedTask.ID, mocks.CreateResponder(200, string(taskResponse[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) globalSet := flag.NewFlagSet("test", 0) globalSet.Bool("non-interactive", true, "doc") globalCtx := cli.NewContext(nil, globalSet, nil) err = globalSet.Parse([]string{"--non-interactive"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } set := flag.NewFlagSet("test", 0) err = set.Parse([]string{deploymentId, "tenant\admingroup"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, globalCtx) err = setDeploymentSecurityGroups(cxt) if err != nil { t.Error(err) t.Error("Not expecting setDeploymentSecurityGroups to fail") } }
func TestImageTasks(t *testing.T) { taskList := MockTasksPage{ Items: []photon.Task{ { Operation: "CREATE_IMAGE", State: "COMPLETED", ID: "1", Entity: photon.Entity{ID: "1", Kind: "image"}, }, }, NextPageLink: "/fake-next-page-link", PreviousPageLink: "", } response, err := json.Marshal(taskList) if err != nil { t.Error("Not expecting error serializaing expected status") } server := mocks.NewTestServer() mocks.RegisterResponder( "GET", server.URL+"/images/1/tasks", mocks.CreateResponder(200, string(response[:]))) taskList = MockTasksPage{ Items: []photon.Task{}, NextPageLink: "", PreviousPageLink: "", } response, err = json.Marshal(taskList) if err != nil { t.Error("Not expecting error serializing expected taskLists") } mocks.RegisterResponder( "GET", server.URL+"/fake-next-page-link", mocks.CreateResponder(200, string(response[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"1"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, nil) err = getImageTasks(cxt) if err != nil { t.Error("Not expecting error retrieving tenant tasks") } }
func TestListVMTasks(t *testing.T) { taskList := MockTasksPage{ Items: []photon.Task{ { Operation: "CREATE_VM", State: "COMPLETED", }, }, NextPageLink: "/fake-next-page-link", PreviousPageLink: "", } response, err := json.Marshal(taskList) if err != nil { t.Error("Not expecting error serializaing expected taskLists") } server := mocks.NewTestServer() mocks.RegisterResponder( "GET", server.URL+"/vms/"+"fake_vm_ID"+"/tasks", mocks.CreateResponder(200, string(response[:]))) taskList = MockTasksPage{ Items: []photon.Task{}, NextPageLink: "", PreviousPageLink: "", } response, err = json.Marshal(taskList) if err != nil { t.Error("Not expecting error serializing expected taskLists") } mocks.RegisterResponder( "GET", server.URL+"/fake-next-page-link", mocks.CreateResponder(200, string(response[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"fake_vm_ID"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, nil) err = getVMTasks(cxt) if err != nil { t.Error("Not expecting error showing VM tasks: " + err.Error()) } }
func TestGetVMMksTicket(t *testing.T) { completedTask := &photon.Task{ Operation: "GET_MKS_TICKET", State: "COMPLETED", ID: "fake-vm-task-ID", Entity: photon.Entity{ID: "fake_vm_ID"}, } response, err := json.Marshal(completedTask) if err != nil { t.Error("Not expecting error serializaing expected completedTask") } mksMap := make(map[string]interface{}) mksMap["ticket"] = "ticket-id" mksTask := &photon.Task{ State: "COMPLETED", ID: "fake-vm-task-ID", Entity: photon.Entity{ID: "fake_vm_ID"}, ResourceProperties: mksMap, } mksresponse, err := json.Marshal(mksTask) if err != nil { t.Error("Not expecting error serializaing expected completedTask") } server := mocks.NewTestServer() mocks.RegisterResponder( "GET", server.URL+"/vms/"+"fake_vm_ID"+"/mks_ticket", mocks.CreateResponder(200, string(response[:]))) mocks.RegisterResponder( "GET", server.URL+"/tasks/"+completedTask.ID, mocks.CreateResponder(200, string(mksresponse[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"fake_vm_ID"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, nil) err = getVMMksTicket(cxt) if err != nil { t.Error("Not expecting error getting vm mks ticket: " + err.Error()) } }
func TestSetVMMetadata(t *testing.T) { queuedTask := &photon.Task{ Operation: "SET_METADATA", State: "QUEUED", ID: "fake-vm-task-ID", Entity: photon.Entity{ID: "fake_vm_ID"}, } taskResponse, err := json.Marshal(queuedTask) if err != nil { t.Error("Not expecting error serializaing expected queuedTask") } completedTask := &photon.Task{ Operation: "SET_METADATA", State: "COMPLETED", ID: "fake-vm-task-ID", Entity: photon.Entity{ID: "fake_vm_ID"}, } response, err := json.Marshal(completedTask) if err != nil { t.Error("Not expecting error serializaing expected completedTask") } server := mocks.NewTestServer() mocks.RegisterResponder( "POST", server.URL+"/vms/"+"fake_vm_ID"+"/set_metadata", mocks.CreateResponder(200, string(taskResponse[:]))) mocks.RegisterResponder( "GET", server.URL+"/tasks/"+queuedTask.ID, mocks.CreateResponder(200, string(response[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"fake_vm_ID"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } set.String("metadata", "{\"a\":\"b\", \"c\":\"d\"}", "vm metadata") cxt := cli.NewContext(nil, set, nil) err = setVMMetadata(cxt) if err != nil { t.Error("Not expecting error setting vm metadata: " + err.Error()) } }
func TestListDisks(t *testing.T) { diskList := MockDisksPage{ Items: []photon.PersistentDisk{ { Name: "fake_disk_name", ID: "fake_disk_ID", Flavor: "fake_flavor_name", Kind: "persistent-disk", CapacityGB: 1, State: "DETACHED", Datastore: "fake_datastore_ID", }, }, NextPageLink: "fake-next-page-link", PreviousPageLink: "", } listResponse, err := json.Marshal(diskList) if err != nil { t.Error("Not expecting error serializaing expected disksList") } mocks.RegisterResponder( "GET", server.URL+"/projects/"+"fake_project_ID"+"/disks", mocks.CreateResponder(200, string(listResponse[:]))) diskList = MockDisksPage{ Items: []photon.PersistentDisk{}, NextPageLink: "", PreviousPageLink: "", } listResponse, err = json.Marshal(diskList) if err != nil { t.Error("Not expecting error serializaing expected disksList") } mocks.RegisterResponder( "GET", server.URL+"fake-next-page-link", mocks.CreateResponder(200, string(listResponse[:]))) set := flag.NewFlagSet("test", 0) set.String("tenant", "fake_tenant_name", "tenant name") set.String("project", "fake_project_name", "project name") cxt := cli.NewContext(nil, set, nil) err = listDisks(cxt) if err != nil { t.Error("Not expecting error listing disks: " + err.Error()) } }
func TestListProjectTasks(t *testing.T) { taskList := MockTasksPage{ Items: []photon.Task{ { Operation: "CREATE_PROJECT", State: "COMPLETED", ID: "fake_project_task_id", Entity: photon.Entity{ID: "fake_project_ID", Kind: "project"}, }, }, NextPageLink: "/fake-next-page-link", PreviousPageLink: "", } response, err := json.Marshal(taskList) if err != nil { t.Error("Not expecting error serializaing expected taskLists") } mocks.RegisterResponder( "GET", server.URL+"/projects/"+"fake_project_ID"+"/tasks", mocks.CreateResponder(200, string(response[:]))) taskList = MockTasksPage{ Items: []photon.Task{}, NextPageLink: "", PreviousPageLink: "", } response, err = json.Marshal(taskList) if err != nil { t.Error("Not expecting error serializing expected taskLists") } mocks.RegisterResponder( "GET", server.URL+"/fake-next-page-link", mocks.CreateResponder(200, string(response[:]))) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"fake_project_ID"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, nil) err = getProjectTasks(cxt, os.Stdout) if err != nil { t.Error("Not expecting error showing project tasks: " + err.Error()) } }
func TestListResourceTicketTasks(t *testing.T) { taskList := MockTasksPage{ Items: []photon.Task{ { Operation: "CREATE_RESOURCE_TICKET", State: "COMPLETED", ID: "fake-rt-task-id", Entity: photon.Entity{ID: rtID}, }, }, NextPageLink: "/fake-next-page-link", PreviousPageLink: "", } response, err := json.Marshal(taskList) if err != nil { t.Error("Not expecting error serializaing expected taskLists") } mocks.RegisterResponder( "GET", server.URL+"/resource-tickets/"+rtID+"/tasks", mocks.CreateResponder(200, string(response[:]))) taskList = MockTasksPage{ Items: []photon.Task{}, NextPageLink: "", PreviousPageLink: "", } response, err = json.Marshal(taskList) if err != nil { t.Error("Not expecting error serializing expected taskLists") } mocks.RegisterResponder( "GET", server.URL+"/fake-next-page-link", mocks.CreateResponder(200, string(response[:]))) set := flag.NewFlagSet("test", 0) set.String("tenant", tenantName, "tenant name") err = set.Parse([]string{rtName}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, nil) err = getResourceTicketTasks(cxt, os.Stdout) if err != nil { t.Error("Not expecting error showing resource ticket tasks: " + err.Error()) } }
func TestResumeSystem(t *testing.T) { queuedTask := &photon.Task{ Operation: "RESUME_SYSTEM", State: "QUEUED", Entity: photon.Entity{ID: "1"}, } completedTask := &photon.Task{ Operation: "RESUME_SYSTEM", State: "COMPLETED", Entity: photon.Entity{ID: "1"}, } response, err := json.Marshal(queuedTask) if err != nil { t.Error("Not expecting error during serializing expected queuedTask") } taskResponse, err := json.Marshal(completedTask) if err != nil { t.Error("Not expecting error during serializing expected completedTask") } server := mocks.NewTestServer() mocks.RegisterResponder( "POST", server.URL+"/deployments/"+queuedTask.Entity.ID+"/resume_system", mocks.CreateResponder(200, string(response[:]))) mocks.RegisterResponder( "GET", server.URL+"/tasks/"+queuedTask.ID, mocks.CreateResponder(200, string(taskResponse[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{queuedTask.Entity.ID}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, nil) err = resumeSystem(cxt) if err != nil { t.Error(err) t.Error("Not expecting resumeSystem to fail") } }
func TestGetDeployment(t *testing.T) { auth := &photon.AuthInfo{ Enabled: false, } stats := &photon.StatsInfo{ Enabled: false, } getStruct := photon.Deployment{ ImageDatastores: []string{"testname"}, ID: "1", Auth: auth, State: "COMPLETED", Stats: stats, } response, err := json.Marshal(getStruct) if err != nil { t.Error("Not expecting error serializaing expected createTask") } server := mocks.NewTestServer() mocks.RegisterResponder( "GET", server.URL+"/deployments/"+getStruct.ID, mocks.CreateResponder(200, string(response[:]))) mocks.RegisterResponder( "GET", server.URL+"/deployments/1/vms", mocks.CreateResponder(200, string(response[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{getStruct.ID}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, nil) err = showDeployment(cxt) if err != nil { t.Error("Not expecting get deployment to fail") } }
func TestShowAvailabilityZone(t *testing.T) { expectedStruct := photon.AvailabilityZone{ ID: "availabilityzone_id", Name: "availabilityzone_name", } response, err := json.Marshal(expectedStruct) if err != nil { t.Error("Not expecting error serializaing expected response") } server := mocks.NewTestServer() mocks.RegisterResponder( "GET", server.URL+"/availabilityzones/"+expectedStruct.ID, mocks.CreateResponder(200, string(response[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{expectedStruct.ID}) cxt := cli.NewContext(nil, set, nil) err = showAvailabilityZone(cxt, os.Stdout) if err != nil { t.Error("Not expecting show availabilityzone to fail: " + err.Error()) } }
func TestShow(t *testing.T) { authInfo := photon.AuthInfo{} response, err := json.Marshal(authInfo) if err != nil { t.Error("Not expecting error serializing expected status") } server := mocks.NewTestServer() mocks.RegisterResponder( "GET", server.URL+"/auth", mocks.CreateResponder(200, string(response[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) set := flag.NewFlagSet("test", 0) cxt := cli.NewContext(nil, set, nil) err = show(cxt) if err != nil { t.Error(err) } }
func TestShowDisk(t *testing.T) { diskStruct := photon.PersistentDisk{ Name: "fake_disk_name", ID: "fake_disk_ID", Flavor: "fake_flavor_name", Kind: "persistent-disk", CapacityGB: 1, State: "DETACHED", Datastore: "fake_datastore_ID", Tags: []string{"fake_disk_tag1", "fake_disk_tag2"}, VMs: []string{"fake_vm_id"}, } response, err := json.Marshal(diskStruct) if err != nil { t.Error("Not expecting error serializaing expected disk") } mocks.RegisterResponder( "GET", server.URL+"/disks/"+"fake_disk_ID", mocks.CreateResponder(200, string(response[:]))) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"fake_disk_ID"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, nil) err = showDisk(cxt) if err != nil { t.Error("Not expecting error showing disk: " + err.Error()) } }
func TestShowNetworks(t *testing.T) { expectedStruct := photon.Subnet{ ID: "network_id", Name: "network_name", PortGroups: []string{"port", "group"}, IsDefault: false, } response, err := json.Marshal(expectedStruct) if err != nil { t.Error("Not expecting error serializing expected response") } server := mocks.NewTestServer() mocks.RegisterResponder( "GET", server.URL+"/subnets/"+expectedStruct.ID, mocks.CreateResponder(200, string(response[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{expectedStruct.ID}) cxt := cli.NewContext(nil, set, nil) err = showNetwork(cxt, os.Stdout) if err != nil { t.Error("Error showing networks: " + err.Error()) } }
func TestShowProject(t *testing.T) { projectStruct := photon.ProjectCompact{ Name: "fake_project_name", ID: "fake_project_ID", ResourceTicket: photon.ProjectTicket{ TenantTicketID: "fake_ticket_id", TenantTicketName: "fake_ticket_name", Limits: []photon.QuotaLineItem{{Key: "vm.test1", Value: 1, Unit: "B"}}, Usage: []photon.QuotaLineItem{{Key: "vm.test1", Value: 0, Unit: "B"}}, }, } response, err := json.Marshal(projectStruct) if err != nil { t.Error("Not expecting error serializaing expected project") } mocks.RegisterResponder( "GET", server.URL+"/projects/"+"fake_project_ID", mocks.CreateResponder(200, string(response[:]))) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"fake_project_ID"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, nil) err = showProject(cxt, os.Stdout) if err != nil { t.Error("Not expecting error showing project: " + err.Error()) } }
func TestShowTenant(t *testing.T) { tenantStruct := &photon.Tenant{ Name: "fake_tenant_name", ID: "fake_tenant_ID", } response, err := json.Marshal(tenantStruct) if err != nil { t.Error("Not expecting error serializaing expected tenant") } mocks.RegisterResponder( "GET", server.URL+"/tenants"+"/"+"fake_tenant_ID", mocks.CreateResponder(200, string(response[:]))) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"fake_tenant_ID"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, nil) err = showTenant(cxt, os.Stdout) if err != nil { t.Error("Not expecting error showing tenant: " + err.Error()) } }
func mockDeploymentsForList(t *testing.T, server *httptest.Server, numDeployments int) error { var deployments []photon.Deployment for i := 0; i < numDeployments; i++ { deployment := photon.Deployment{ ID: strconv.Itoa(i), } deployments = append(deployments, deployment) } expectedStruct := photon.Deployments{ Items: deployments, } response, err := json.Marshal(expectedStruct) if err != nil { return err } mocks.RegisterResponder( "GET", server.URL+"/deployments", mocks.CreateResponder(200, string(response[:]))) return nil }
func TestSetHostAvailabilityZone(t *testing.T) { queuedTask := &photon.Task{ Operation: "SET_AVAILABILITYZONE", State: "QUEUED", ID: "fake-task-id", Entity: photon.Entity{ID: "fake-host-id"}, } completedTask := &photon.Task{ Operation: "SET_AVAILABILITYZONE", State: "COMPLETED", ID: "fake-task-id", Entity: photon.Entity{ID: "fake-host-id"}, } response, err := json.Marshal(queuedTask) if err != nil { t.Error("Not expecting error serializing expected createTask") } taskResponse, err := json.Marshal(completedTask) if err != nil { t.Error("Not expecting error serializing expected createTask") } server := mocks.NewTestServer() mocks.RegisterResponder( "POST", server.URL+"/hosts"+"/fake-host-id"+"/set_availability_zone", mocks.CreateResponder(200, string(response[:]))) mocks.RegisterResponder( "GET", server.URL+"/tasks/"+queuedTask.ID, mocks.CreateResponder(200, string(taskResponse[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"fake-host-id", "fake-availability-zone-id"}) cxt := cli.NewContext(nil, set, nil) err = setHostAvailabilityZone(cxt, os.Stdout) if err != nil { t.Error("Error listing hosts: " + err.Error()) } }
func TestSuspendVM(t *testing.T) { queuedTask := &photon.Task{ Operation: "SUSPEND_VM", State: "QUEUED", ID: "fake-vm-task-ID", Entity: photon.Entity{ID: "fake_vm_ID"}, } taskResponse, err := json.Marshal(queuedTask) if err != nil { t.Error("Not expecting error serializaing expected queuedTask") } completedTask := &photon.Task{ Operation: "SUSPEND_VM", State: "COMPLETED", ID: "fake-vm-task-IDS", Entity: photon.Entity{ID: "fake_vm_ID"}, } response, err := json.Marshal(completedTask) if err != nil { t.Error("Not expecting error serializaing expected completedTask") } mocks.RegisterResponder( "POST", server.URL+"/vms/"+"fake_vm_ID"+"/suspend", mocks.CreateResponder(200, string(taskResponse[:]))) mocks.RegisterResponder( "GET", server.URL+"/tasks/"+queuedTask.ID, mocks.CreateResponder(200, string(response[:]))) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"fake_vm_ID"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, nil) err = suspendVM(cxt) if err != nil { t.Error("Not expecting error suspending VM: " + err.Error()) } }
func TestSetDefaultNetwork(t *testing.T) { completedTask := &photon.Task{ Operation: "SET_DEFAULT_NETWORK", State: "COMPLETED", Entity: photon.Entity{ID: "id"}, } taskresponse, err := json.Marshal(completedTask) if err != nil { t.Error("Not expecting error serializing expected completedTask") } server := mocks.NewTestServer() mocks.RegisterResponder( "POST", server.URL+"/subnets/"+completedTask.Entity.ID+"/set_default", mocks.CreateResponder(200, string(taskresponse[:]))) mocks.RegisterResponder( "GET", server.URL+"/tasks/"+completedTask.ID, mocks.CreateResponder(200, string(taskresponse[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) globalSet := flag.NewFlagSet("test", 0) globalSet.Bool("non-interactive", true, "doc") globalCtx := cli.NewContext(nil, globalSet, nil) err = globalSet.Parse([]string{"--non-interactive"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } set := flag.NewFlagSet("test", 0) err = set.Parse([]string{completedTask.Entity.ID}) cxt := cli.NewContext(nil, set, globalCtx) err = setDefaultNetwork(cxt, os.Stdout) if err != nil { t.Error("Not expecting set default network to fail", err) } }
func TestDeleteDisk(t *testing.T) { queuedTask := &photon.Task{ Operation: "DELETE_DISK", State: "QUEUED", ID: "fake-disk-task-ID", Entity: photon.Entity{ID: "fake_disk_ID"}, } taskResponse, err := json.Marshal(queuedTask) if err != nil { t.Error("Not expecting error serializaing expected queuedTask") } completedTask := &photon.Task{ Operation: "DELETE_DISK", State: "COMPLETED", ID: "fake-disk-task-ID", Entity: photon.Entity{ID: "fake_disk_ID"}, } response, err := json.Marshal(completedTask) if err != nil { t.Error("Not expecting error serializaing expected completedTask") } mocks.RegisterResponder( "DELETE", server.URL+"/disks/"+"fake_disk_ID", mocks.CreateResponder(200, string(taskResponse[:]))) mocks.RegisterResponder( "GET", server.URL+"/tasks/"+queuedTask.ID, mocks.CreateResponder(200, string(response[:]))) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"fake_disk_ID"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, nil) err = deleteDisk(cxt) if err != nil { t.Error("Not expecting error deleting disk: " + err.Error()) } }
func TestAttachDisk(t *testing.T) { queuedTask := &photon.Task{ Operation: "ATTACH_DISK", State: "QUEUED", ID: "fake-vm-task-ID", } taskResponse, err := json.Marshal(queuedTask) if err != nil { t.Error("Not expecting error serializaing expected queuedTask") } completedTask := &photon.Task{ Operation: "ATTACH_DISK", State: "COMPLETED", ID: "fake-vm-task-IDS", } response, err := json.Marshal(completedTask) if err != nil { t.Error("Not expecting error serializaing expected completedTask") } mocks.RegisterResponder( "POST", server.URL+"/vms/"+"fake_vm_ID"+"/attach_disk", mocks.CreateResponder(200, string(taskResponse[:]))) mocks.RegisterResponder( "GET", server.URL+"/tasks/"+queuedTask.ID, mocks.CreateResponder(200, string(response[:]))) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"fake_vm_ID"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } set.String("disk", "fake_disk_ID", "attach disk") cxt := cli.NewContext(nil, set, nil) err = attachDisk(cxt) if err != nil { t.Error("Not expecting error attaching disk: " + err.Error()) } }
func mockHostsForList(t *testing.T, server *httptest.Server) error { hostList := MockHostsPage{ Items: []photon.Host{ { Username: "******", Password: "******", Address: "testIP", Tags: []string{"CLOUD"}, ID: "host-test-id", State: "COMPLETED", }, }, NextPageLink: "/fake-next-page-link", PreviousPageLink: "", } response, err := json.Marshal(hostList) if err != nil { return err } mocks.RegisterResponder( "GET", server.URL+"/deployments/0/hosts", mocks.CreateResponder(200, string(response[:]))) hostList = MockHostsPage{ Items: []photon.Host{}, NextPageLink: "", PreviousPageLink: "", } response, err = json.Marshal(hostList) if err != nil { return err } mocks.RegisterResponder( "GET", server.URL+"/fake-next-page-link", mocks.CreateResponder(200, string(response[:]))) return nil }
func TestSetSecurityGroupsForProject(t *testing.T) { taskId := "task1" projectId := "project1" completedTask := photon.Task{ ID: taskId, Operation: "PUSH_TENANT_SECURITY_GROUPS", State: "COMPLETED", Entity: photon.Entity{ID: projectId}, } response, err := json.Marshal(completedTask) if err != nil { t.Error("Not expecting error serializaing expected status") } server := mocks.NewTestServer() mocks.RegisterResponder( "POST", server.URL+"/projects/"+projectId+"/set_security_groups", mocks.CreateResponder(200, string(response[:]))) mocks.RegisterResponder( "GET", server.URL+"/tasks/"+taskId, mocks.CreateResponder(200, string(response[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{projectId, "sg1"}) if err != nil { t.Error(err) } cxt := cli.NewContext(nil, set, nil) err = setSecurityGroupsForProject(cxt) if err != nil { t.Error(err) } }
func TestHostGetVMs(t *testing.T) { vmListStruct := photon.VMs{ Items: []photon.VM{ { Name: "fake_vm_name", ID: "fake_vm_ID", Flavor: "fake_vm_flavor_name", State: "STOPPED", SourceImageID: "fake_image_ID", Host: "fake_host_ip", Datastore: "fake_datastore_ID", AttachedDisks: []photon.AttachedDisk{ { Name: "d1", Kind: "ephemeral-disk", Flavor: "fake_ephemeral_flavor_ID", CapacityGB: 0, BootDisk: true, }, }, }, }, } response, err := json.Marshal(vmListStruct) if err != nil { t.Error("Not expecting error serializing host list") } server := mocks.NewTestServer() mocks.RegisterResponder( "GET", server.URL+"/hosts/1/vms", mocks.CreateResponder(200, string(response[:]))) defer server.Close() mocks.Activate(true) httpClient := &http.Client{Transport: mocks.DefaultMockTransport} client.Esxclient = photon.NewTestClient(server.URL, nil, httpClient) set := flag.NewFlagSet("test", 0) err = set.Parse([]string{"1"}) if err != nil { t.Error("Not expecting arguments parsing to fail") } cxt := cli.NewContext(nil, set, nil) err = listHostVMs(cxt, os.Stdout) if err != nil { t.Error("Not expecting deployment list hosts to fail") } }