chore(ollama): use Run function (#3420)

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Claude <[email protected]>

Author: mdelapenya

modules/ollama/local.go

@@ -90,8 +90,21 @@ type localProcess struct {
 	binary string
 }
 
-// runLocal returns an OllamaContainer that uses the local Ollama binary instead of using a Docker container.
-func (c *localProcess) run(ctx context.Context, req testcontainers.GenericContainerRequest) (*OllamaContainer, error) {
+// run returns an OllamaContainer that uses the local Ollama binary instead of using a Docker container.
+func (c *localProcess) run(ctx context.Context, img string, opts []testcontainers.ContainerCustomizer) (*OllamaContainer, error) {
+	req := testcontainers.GenericContainerRequest{
+		ContainerRequest: testcontainers.ContainerRequest{
+			Image: img,
+		},
+		Started: true,
+	}
+
+	for _, opt := range opts {
+		if err := opt.Customize(&req); err != nil {
+			return nil, fmt.Errorf("customize: %w", err)
+		}
+	}
+
 	if err := c.validateRequest(req); err != nil {
 		return nil, fmt.Errorf("validate request: %w", err)
 	}
@@ -714,7 +727,11 @@ func (c *localProcess) Customize(req *testcontainers.GenericContainerRequest) er
 	if req.WaitingFor == nil {
 		req.WaitingFor = logStrategy
 	} else {
-		req.WaitingFor = wait.ForAll(req.WaitingFor, logStrategy)
+		if w, ok := req.WaitingFor.(*wait.MultiStrategy); ok && len(w.Strategies) == 0 {
+			w.Strategies = append(w.Strategies, logStrategy)
+		} else {
+			req.WaitingFor = logStrategy
+		}
 	}
 
 	// Setup the environment variables using a random port by default

modules/ollama/ollama.go

@@ -74,41 +74,40 @@ func RunContainer(ctx context.Context, opts ...testcontainers.ContainerCustomize
 
 // Run creates an instance of the Ollama container type
 func Run(ctx context.Context, img string, opts ...testcontainers.ContainerCustomizer) (*OllamaContainer, error) {
-	req := testcontainers.GenericContainerRequest{
-		ContainerRequest: testcontainers.ContainerRequest{
-			Image:        img,
-			ExposedPorts: []string{"11434/tcp"},
-			WaitingFor:   wait.ForListeningPort("11434/tcp").WithStartupTimeout(60 * time.Second),
-		},
-		Started: true,
+	moduleOpts := []testcontainers.ContainerCustomizer{
+		testcontainers.WithExposedPorts("11434/tcp"),
+		testcontainers.WithWaitStrategy(wait.ForListeningPort("11434/tcp").WithStartupTimeout(60 * time.Second)),
 	}
 
-	// Always request a GPU if the host supports it.
-	opts = append(opts, withGpu())
-
+	// Check if we need to use the local process
 	var local *localProcess
 	for _, opt := range opts {
-		if err := opt.Customize(&req); err != nil {
-			return nil, fmt.Errorf("customize: %w", err)
-		}
 		if l, ok := opt.(*localProcess); ok {
 			local = l
+			break
 		}
 	}
 
+	// Only request a GPU if NOT using local process and the host supports it.
+	if local == nil {
+		opts = append(opts, withGpu())
+	}
+
+	moduleOpts = append(moduleOpts, opts...)
+
 	// Now we have processed all the options, we can check if we need to use the local process.
 	if local != nil {
-		return local.run(ctx, req)
+		return local.run(ctx, img, moduleOpts)
 	}
 
-	container, err := testcontainers.GenericContainer(ctx, req)
+	ctr, err := testcontainers.Run(ctx, img, moduleOpts...)
 	var c *OllamaContainer
-	if container != nil {
-		c = &OllamaContainer{Container: container}
+	if ctr != nil {
+		c = &OllamaContainer{Container: ctr}
 	}
 
 	if err != nil {
-		return c, fmt.Errorf("generic container: %w", err)
+		return c, fmt.Errorf("run ollama: %w", err)
 	}
 
 	return c, nil