Move common simulator tests helper functions to test_utils.go, use same model name is all tests, refactoring in server start functions

Signed-off-by: Maya Barnea <[email protected]>

Author: mayabar

pkg/llm-d-inference-sim/failures_test.go

@@ -126,15 +126,15 @@ var _ = Describe("Failures", func() {
 			BeforeEach(func() {
 				ctx = context.Background()
 				var err error
-				client, err = startServerWithArgs(ctx, "", []string{
-					"cmd", "--model", model,
+				client, err = startServerWithArgs(ctx, []string{
+					"cmd", "--model", testModel,
 					"--failure-injection-rate", "100",
-				}, nil)
+				})
 				Expect(err).ToNot(HaveOccurred())
 			})
 
 			It("should always return an error response for chat completions", func() {
-				openaiClient, params := getOpenAIClientAndChatParams(client, model, userMessage, false)
+				openaiClient, params := getOpenAIClientAndChatParams(client, testModel, testUserMessage, false)
 				_, err := openaiClient.Chat.Completions.New(ctx, params)
 				Expect(err).To(HaveOccurred())
 
@@ -147,7 +147,7 @@ var _ = Describe("Failures", func() {
 			})
 
 			It("should always return an error response for text completions", func() {
-				openaiClient, params := getOpenAIClientAndChatParams(client, model, userMessage, false)
+				openaiClient, params := getOpenAIClientAndChatParams(client, testModel, testUserMessage, false)
 				_, err := openaiClient.Chat.Completions.New(ctx, params)
 				Expect(err).To(HaveOccurred())
 
@@ -164,16 +164,16 @@ var _ = Describe("Failures", func() {
 			BeforeEach(func() {
 				ctx = context.Background()
 				var err error
-				client, err = startServerWithArgs(ctx, "", []string{
-					"cmd", "--model", model,
+				client, err = startServerWithArgs(ctx, []string{
+					"cmd", "--model", testModel,
 					"--failure-injection-rate", "100",
 					"--failure-types", common.FailureTypeRateLimit,
-				}, nil)
+				})
 				Expect(err).ToNot(HaveOccurred())
 			})
 
 			It("should return only rate limit errors", func() {
-				openaiClient, params := getOpenAIClientAndChatParams(client, model, userMessage, false)
+				openaiClient, params := getOpenAIClientAndChatParams(client, testModel, testUserMessage, false)
 				_, err := openaiClient.Chat.Completions.New(ctx, params)
 				Expect(err).To(HaveOccurred())
 
@@ -182,24 +182,24 @@ var _ = Describe("Failures", func() {
 				Expect(ok).To(BeTrue())
 				Expect(openaiError.StatusCode).To(Equal(429))
 				Expect(openaiError.Type).To(Equal(openaiserverapi.ErrorCodeToType(429)))
-				Expect(strings.Contains(openaiError.Message, model)).To(BeTrue())
+				Expect(strings.Contains(openaiError.Message, testModel)).To(BeTrue())
 			})
 		})
 
 		Context("with multiple specific failure types", func() {
 			BeforeEach(func() {
 				ctx = context.Background()
 				var err error
-				client, err = startServerWithArgs(ctx, "", []string{
-					"cmd", "--model", model,
+				client, err = startServerWithArgs(ctx, []string{
+					"cmd", "--model", testModel,
 					"--failure-injection-rate", "100",
 					"--failure-types", common.FailureTypeInvalidAPIKey, common.FailureTypeServerError,
-				}, nil)
+				})
 				Expect(err).ToNot(HaveOccurred())
 			})
 
 			It("should return only specified error types", func() {
-				openaiClient, params := getOpenAIClientAndChatParams(client, model, userMessage, false)
+				openaiClient, params := getOpenAIClientAndChatParams(client, testModel, testUserMessage, false)
 
 				// Make multiple requests to verify we get the expected error types
 				for i := 0; i < 10; i++ {
@@ -222,35 +222,35 @@ var _ = Describe("Failures", func() {
 			BeforeEach(func() {
 				ctx = context.Background()
 				var err error
-				client, err = startServerWithArgs(ctx, "", []string{
-					"cmd", "--model", model,
+				client, err = startServerWithArgs(ctx, []string{
+					"cmd", "--model", testModel,
 					"--failure-injection-rate", "0",
-				}, nil)
+				})
 				Expect(err).ToNot(HaveOccurred())
 			})
 
 			It("should never return errors and behave like random mode", func() {
-				openaiClient, params := getOpenAIClientAndChatParams(client, model, userMessage, false)
+				openaiClient, params := getOpenAIClientAndChatParams(client, testModel, testUserMessage, false)
 				resp, err := openaiClient.Chat.Completions.New(ctx, params)
 				Expect(err).ToNot(HaveOccurred())
 				Expect(resp.Choices).To(HaveLen(1))
 				Expect(resp.Choices[0].Message.Content).ToNot(BeEmpty())
-				Expect(resp.Model).To(Equal(model))
+				Expect(resp.Model).To(Equal(testModel))
 			})
 		})
 
 		Context("testing all predefined failure types", func() {
 			DescribeTable("should return correct error for each failure type",
 				func(failureType string, expectedStatusCode int, expectedErrorType string) {
 					ctx := context.Background()
-					client, err := startServerWithArgs(ctx, "", []string{
-						"cmd", "--model", model,
+					client, err := startServerWithArgs(ctx, []string{
+						"cmd", "--model", testModel,
 						"--failure-injection-rate", "100",
 						"--failure-types", failureType,
-					}, nil)
+					})
 					Expect(err).ToNot(HaveOccurred())
 
-					openaiClient, params := getOpenAIClientAndChatParams(client, model, userMessage, false)
+					openaiClient, params := getOpenAIClientAndChatParams(client, testModel, testUserMessage, false)
 					_, err = openaiClient.Chat.Completions.New(ctx, params)
 					Expect(err).To(HaveOccurred())
 

pkg/llm-d-inference-sim/lora_test.go

@@ -34,22 +34,22 @@ var _ = Describe("LoRAs", func() {
 	Context("LoRAs config and load", func() {
 		It("Should config, load and load LoRAs correctly", func() {
 			ctx := context.TODO()
-			client, err := startServerWithArgs(ctx, "",
-				[]string{"cmd", "--model", model, "--mode", common.ModeEcho,
+			client, err := startServerWithArgs(ctx,
+				[]string{"cmd", "--model", testModel, "--mode", common.ModeEcho,
 					"--lora-modules", "{\"name\":\"lora3\",\"path\":\"/path/to/lora3\"}",
-					"{\"name\":\"lora4\",\"path\":\"/path/to/lora4\"}"}, nil)
+					"{\"name\":\"lora4\",\"path\":\"/path/to/lora4\"}"})
 			Expect(err).NotTo(HaveOccurred())
 
 			// Request to lora3
-			openaiclient, params := getOpenAIClientAndChatParams(client, "lora3", userMessage, false)
+			openaiclient, params := getOpenAIClientAndChatParams(client, "lora3", testUserMessage, false)
 			resp, err := openaiclient.Chat.Completions.New(ctx, params)
 			Expect(err).ToNot(HaveOccurred())
 
 			Expect(resp.Choices).ShouldNot(BeEmpty())
 			Expect(string(resp.Object)).To(Equal(chatCompletionObject))
 
 			msg := resp.Choices[0].Message.Content
-			Expect(msg).Should(Equal(userMessage))
+			Expect(msg).Should(Equal(testUserMessage))
 
 			// Unknown model, should return 404
 			params.Model = "lora1"
@@ -88,7 +88,7 @@ var _ = Describe("LoRAs", func() {
 			Expect(string(resp.Object)).To(Equal(chatCompletionObject))
 
 			msg = resp.Choices[0].Message.Content
-			Expect(msg).Should(Equal(userMessage))
+			Expect(msg).Should(Equal(testUserMessage))
 
 			// Unload lora3
 			payload = map[string]string{