new unit tests

api/scheduler_handler_test.go

@@ -1108,6 +1108,27 @@ ports:
 				Expect(pods.Items).To(HaveLen(replicas))
 			})
 
+			It("should return error if replicas is negative", func() {
+				replicas := -1
+				body := map[string]interface{}{"replicas": replicas}
+				bts, _ := json.Marshal(body)
+				reader := strings.NewReader(string(bts))
+
+				url := fmt.Sprintf("http://%s/scheduler/%s", app.Address, schedulerName)
+				request, err := http.NewRequest("POST", url, reader)
+				Expect(err).NotTo(HaveOccurred())
+
+				app.Router.ServeHTTP(recorder, request)
+				Expect(recorder.Code).To(Equal(http.StatusUnprocessableEntity))
+				response := make(map[string]interface{})
+				err = json.Unmarshal(recorder.Body.Bytes(), &response)
+				Expect(err).NotTo(HaveOccurred())
+				Expect(response["error"]).To(Equal("ValidationFailedError"))
+				Expect(response["description"]).To(ContainSubstring("yaml: unmarshal errors:"))
+				Expect(response["code"]).To(Equal("MAE-004"))
+				Expect(response["success"]).To(Equal(false))
+			})
+
 			It("should manually choose the number of replicas and scale down", func() {
 				//scale up
 				replicasBefore := 5
@@ -1204,6 +1225,102 @@ ports:
 				Expect(pods.Items).To(HaveLen(replicasAfter))
 			})
 
+			It("should set to 0 replicas", func() {
+				//scale up
+				replicasBefore := 5
+				body := map[string]interface{}{"replicas": replicasBefore}
+				bts, _ := json.Marshal(body)
+				reader := strings.NewReader(string(bts))
+
+				url := fmt.Sprintf("http://%s/scheduler/%s", app.Address, schedulerName)
+				request, err := http.NewRequest("POST", url, reader)
+				Expect(err).NotTo(HaveOccurred())
+
+				mockDb.EXPECT().
+					Query(gomock.Any(), "SELECT * FROM schedulers WHERE name = ?", schedulerName).
+					Do(func(scheduler *models.Scheduler, query string, modifier string) {
+						scheduler.YAML = yamlStr
+					})
+
+				mockRedisClient.EXPECT().TxPipeline().Return(mockPipeline).Times(replicasBefore)
+				mockPipeline.EXPECT().HMSet(gomock.Any(), gomock.Any()).Do(
+					func(schedulerName string, statusInfo map[string]interface{}) {
+						Expect(statusInfo["status"]).To(Equal(models.StatusCreating))
+						Expect(statusInfo["lastPing"]).To(BeNumerically("~", time.Now().Unix(), 1))
+					},
+				).Times(replicasBefore)
+				mockPipeline.EXPECT().ZAdd(models.GetRoomPingRedisKey("scheduler-name"), gomock.Any()).Times(replicasBefore)
+				mockPipeline.EXPECT().SAdd(models.GetRoomStatusSetRedisKey("scheduler-name", "creating"), gomock.Any()).Times(replicasBefore)
+				mockPipeline.EXPECT().Exec().Times(replicasBefore)
+
+				mockRedisClient.EXPECT().TxPipeline().Return(mockPipeline).Times(replicasBefore)
+				mockPipeline.EXPECT().SPop(models.FreePortsRedisKey()).
+					Return(goredis.NewStringResult("5000", nil)).Times(replicasBefore)
+				mockPipeline.EXPECT().Exec().Times(replicasBefore)
+
+				app.Router.ServeHTTP(recorder, request)
+				Expect(recorder.Code).To(Equal(http.StatusOK))
+				Expect(recorder.Body.String()).To(Equal(`{"success": true}`))
+
+				pods, err := clientset.CoreV1().Pods(schedulerName).List(metav1.ListOptions{})
+				Expect(err).NotTo(HaveOccurred())
+				Expect(pods.Items).To(HaveLen(replicasBefore))
+
+				//scale down
+				replicasAfter := 0
+				body = map[string]interface{}{"replicas": replicasAfter}
+				bts, _ = json.Marshal(body)
+				reader = strings.NewReader(string(bts))
+
+				mockDb.EXPECT().
+					Query(gomock.Any(), "SELECT * FROM schedulers WHERE name = ?", schedulerName).
+					Do(func(scheduler *models.Scheduler, query string, modifier string) {
+						scheduler.YAML = yamlStr
+					})
+
+				names, err := controller.GetPodNames(replicasBefore-replicasAfter, schedulerName, clientset)
+				Expect(err).NotTo(HaveOccurred())
+
+				readyKey := models.GetRoomStatusSetRedisKey(schedulerName, models.StatusReady)
+				mockRedisClient.EXPECT().TxPipeline().Return(mockPipeline)
+				for _, name := range names {
+					mockPipeline.EXPECT().SPop(readyKey).Return(redis.NewStringResult(name, nil))
+
+				}
+				mockPipeline.EXPECT().Exec()
+
+				for _, name := range names {
+					mockRedisClient.EXPECT().TxPipeline().Return(mockPipeline)
+					room := models.NewRoom(name, schedulerName)
+					for _, status := range allStatus {
+						mockPipeline.EXPECT().
+							SRem(models.GetRoomStatusSetRedisKey(room.SchedulerName, status), room.GetRoomRedisKey())
+						mockPipeline.EXPECT().
+							ZRem(models.GetLastStatusRedisKey(room.SchedulerName, status), room.ID)
+					}
+					mockPipeline.EXPECT().ZRem(models.GetRoomPingRedisKey(schedulerName), room.ID)
+					mockPipeline.EXPECT().Del(room.GetRoomRedisKey())
+					mockPipeline.EXPECT().Exec()
+
+					mockRedisClient.EXPECT().TxPipeline().Return(mockPipeline)
+					mockPipeline.EXPECT().SAdd(models.FreePortsRedisKey(), gomock.Any())
+					mockPipeline.EXPECT().Exec()
+				}
+
+				url = fmt.Sprintf("http://%s/scheduler/%s", app.Address, schedulerName)
+				request, err = http.NewRequest("POST", url, reader)
+				Expect(err).NotTo(HaveOccurred())
+
+				recorder = httptest.NewRecorder()
+				app.Router.ServeHTTP(recorder, request)
+				Expect(recorder.Code).To(Equal(http.StatusOK))
+				Expect(recorder.Body.String()).To(Equal(`{"success": true}`))
+
+				pods, err = clientset.CoreV1().Pods(schedulerName).List(metav1.ListOptions{})
+				Expect(err).NotTo(HaveOccurred())
+				Expect(pods.Items).To(HaveLen(replicasAfter))
+			})
+
 			It("should return 400 if scaleup and scaledown are both specified", func() {
 				body := map[string]interface{}{"scaledown": 1, "scaleup": 1}
 				bts, _ := json.Marshal(body)