volcano.sh/volcano@v1.9.0/pkg/cli/queue/queue_test.go (about)

     1  /*
     2  Copyright 2019 The Volcano Authors.
     3  
     4  Licensed under the Apache License, Version 2.0 (the "License");
     5  you may not use this file except in compliance with the License.
     6  You may obtain a copy of the License at
     7  
     8      http://www.apache.org/licenses/LICENSE-2.0
     9  
    10  Unless required by applicable law or agreed to in writing, software
    11  distributed under the License is distributed on an "AS IS" BASIS,
    12  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13  See the License for the specific language governing permissions and
    14  limitations under the License.
    15  */
    16  
    17  package queue
    18  
    19  import (
    20  	"encoding/json"
    21  	"fmt"
    22  	"net/http"
    23  	"net/http/httptest"
    24  	"testing"
    25  
    26  	"github.com/spf13/cobra"
    27  
    28  	v1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    29  
    30  	"volcano.sh/apis/pkg/apis/scheduling/v1beta1"
    31  )
    32  
    33  func getTestQueueHTTPServer(t *testing.T) *httptest.Server {
    34  
    35  	response := v1beta1.Queue{}
    36  
    37  	response.Name = "testQueue"
    38  	response.Spec.Weight = int32(2)
    39  
    40  	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    41  		w.Header().Set("Content-Type", "application/json")
    42  		val, err := json.Marshal(response)
    43  		if err == nil {
    44  			w.Write(val)
    45  		}
    46  	})
    47  	return httptest.NewServer(handler)
    48  }
    49  
    50  func getTestQueueListHTTPServer(t *testing.T) *httptest.Server {
    51  
    52  	response := v1beta1.QueueList{}
    53  
    54  	response.Items = []v1beta1.Queue{
    55  		{
    56  			ObjectMeta: v1.ObjectMeta{
    57  				Name: "testQueue",
    58  			},
    59  			Spec: v1beta1.QueueSpec{
    60  				Weight: int32(2),
    61  			},
    62  		},
    63  	}
    64  
    65  	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    66  		w.Header().Set("Content-Type", "application/json")
    67  		val, err := json.Marshal(response)
    68  		if err == nil {
    69  			w.Write(val)
    70  		}
    71  	})
    72  	return httptest.NewServer(handler)
    73  }
    74  
    75  func getCommonFlags(master string) commonFlags {
    76  	return commonFlags{
    77  		Master: master,
    78  	}
    79  }
    80  
    81  func TestCreateQueue(t *testing.T) {
    82  	InitCreateFlags(&cobra.Command{})
    83  	server := getTestQueueHTTPServer(t)
    84  	defer server.Close()
    85  
    86  	createQueueFlags.commonFlags = getCommonFlags(server.URL)
    87  	createQueueFlags.Name = "testQueue"
    88  	createQueueFlags.Weight = int32(2)
    89  
    90  	testCases := []struct {
    91  		Name        string
    92  		ExpectValue error
    93  	}{
    94  		{
    95  			Name:        "CreateQueue",
    96  			ExpectValue: nil,
    97  		},
    98  	}
    99  	for _, testcase := range testCases {
   100  		err := CreateQueue()
   101  		if err != nil {
   102  			t.Errorf("(%s): expected: %v, got %v ", testcase.Name, testcase.ExpectValue, err)
   103  		}
   104  	}
   105  }
   106  
   107  func TestGetQueue(t *testing.T) {
   108  	InitGetFlags(&cobra.Command{})
   109  	server := getTestQueueHTTPServer(t)
   110  	defer server.Close()
   111  
   112  	getQueueFlags.commonFlags = getCommonFlags(server.URL)
   113  
   114  	testCases := []struct {
   115  		Name        string
   116  		ExpectValue error
   117  		QueueName   string
   118  	}{
   119  		{
   120  			Name:        "GetQueue",
   121  			ExpectValue: nil,
   122  			QueueName:   "testQueue",
   123  		},
   124  		{
   125  			Name:        "",
   126  			ExpectValue: fmt.Errorf("name is mandatory to get the particular queue details"),
   127  			QueueName:   "",
   128  		},
   129  	}
   130  	for _, testcase := range testCases {
   131  		getQueueFlags.Name = testcase.QueueName
   132  		err := GetQueue()
   133  		if err != nil && (err.Error() != testcase.ExpectValue.Error()) {
   134  			t.Errorf("(%s): expected: %v, got %v ", testcase.Name, testcase.ExpectValue, err)
   135  		}
   136  	}
   137  }
   138  
   139  func TestListQueue_empty(t *testing.T) {
   140  	InitListFlags(&cobra.Command{})
   141  	server := getTestQueueHTTPServer(t)
   142  	defer server.Close()
   143  
   144  	listQueueFlags.commonFlags = getCommonFlags(server.URL)
   145  
   146  	testCases := []struct {
   147  		Name        string
   148  		ExpectValue error
   149  		QueueName   string
   150  	}{
   151  		{
   152  			Name:        "GetQueue",
   153  			ExpectValue: nil,
   154  		},
   155  	}
   156  	for _, testcase := range testCases {
   157  		err := ListQueue()
   158  		if err != nil && (err.Error() != testcase.ExpectValue.Error()) {
   159  			t.Errorf("(%s): expected: %v, got %v ", testcase.Name, testcase.ExpectValue, err)
   160  		}
   161  	}
   162  }
   163  
   164  func TestListQueue_nonempty(t *testing.T) {
   165  	InitListFlags(&cobra.Command{})
   166  	server := getTestQueueListHTTPServer(t)
   167  	defer server.Close()
   168  
   169  	listQueueFlags.commonFlags = getCommonFlags(server.URL)
   170  
   171  	testCases := []struct {
   172  		Name        string
   173  		ExpectValue error
   174  		QueueName   string
   175  	}{
   176  		{
   177  			Name:        "GetQueue",
   178  			ExpectValue: nil,
   179  			QueueName:   "testQueue",
   180  		},
   181  		{
   182  			Name:        "",
   183  			ExpectValue: fmt.Errorf("name is mandatory to get the particular queue details"),
   184  			QueueName:   "",
   185  		},
   186  	}
   187  	for _, testcase := range testCases {
   188  		err := ListQueue()
   189  		if err != nil && err.Error() != testcase.ExpectValue.Error() {
   190  			t.Errorf("(%s): expected: %v, got %v ", testcase.Name, testcase.ExpectValue, err)
   191  		}
   192  	}
   193  }