Support methods without streams by testing/codegen

testing/codegen/harness.go

@@ -206,7 +206,7 @@ func testingPath(_ string, svc *expr.ServiceExpr) string {
 // hasStreams checks if the service has streaming methods.
 func hasStreams(svc *expr.ServiceExpr) bool {
 	for _, m := range svc.Methods {
-		if m.Stream != expr.NoStreamKind {
+		if m.IsStreaming() {
 			return true
 		}
 	}

testing/codegen/harness_test.go

@@ -0,0 +1,57 @@
+package codegen
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+	"goa.design/goa/v3/codegen"
+	"goa.design/goa/v3/codegen/service"
+	httpcodegen "goa.design/goa/v3/http/codegen"
+	"goa.design/plugins/v3/testing/codegen/testdata"
+)
+
+func TestGenerateHarness(t *testing.T) {
+	cases := map[string]struct {
+		DSL  func()
+		Code map[string][]string
+		Path string
+	}{
+		"with-stream": {
+			DSL: testdata.WithStreamDSL,
+			Code: map[string][]string{
+				"http-harness": {testdata.WithStreamCode},
+			},
+			Path: "gen/with_stream_service/with_stream_servicetest/harness.go",
+		},
+		"without-stream": {
+			DSL: testdata.WithoutStreamDSL,
+			Code: map[string][]string{
+				"http-harness": {testdata.WithoutStreamCode},
+			},
+			Path: "gen/without_stream_service/without_stream_servicetest/harness.go",
+		},
+	}
+	for name, c := range cases {
+		t.Run(name, func(t *testing.T) {
+			root := httpcodegen.RunHTTPDSL(t, c.DSL)
+			services := service.NewServicesData(root)
+			svc := root.Services[0]
+			svcData := services.Get(svc.Name)
+			f := generateHarness("", svcData, root, svc)
+			assert.Equal(t, c.Path, f.Path)
+			for sec, secCode := range c.Code {
+				testCode(t, f, sec, secCode)
+			}
+		})
+	}
+}
+
+func testCode(t *testing.T, file *codegen.File, section string, expCode []string) {
+	sections := file.Section(section)
+	require.Len(t, sections, len(expCode))
+	for i, c := range expCode {
+		code := codegen.SectionCode(t, sections[i])
+		assert.Equal(t, c, code)
+	}
+}

testing/codegen/templates/http_harness.go.tpl

@@ -5,11 +5,13 @@ func (h *Harness) setupHTTP() {
 
 	// Create HTTP handler
 	mux := goahttp.NewMuxer()
+	{{- if .HasStreams }}
 	// Create WebSocket upgrader for streaming endpoints
 	upgrader := &websocket.Upgrader{
 		CheckOrigin: func(r *http.Request) bool { return true },
 	}
-	server := httpsvr.New(endpoints, mux, goahttp.RequestDecoder, goahttp.ResponseEncoder, nil, nil, upgrader, nil)
+	{{- end }}
+	server := httpsvr.New(endpoints, mux, goahttp.RequestDecoder, goahttp.ResponseEncoder, nil, nil{{ if .HasStreams }}, upgrader, nil{{ end }})
 	httpsvr.Mount(mux, server)
 
 	// Create test server
@@ -31,46 +33,50 @@ func (h *Harness) HTTPClient() *http.Client {
 
 {{ printf "getHTTPClientImpl returns the underlying HTTP client implementation." | comment }}
 func (h *Harness) getHTTPClientImpl() *httpcli.Client {
-    if h.httpSvr == nil || h.httpCli == nil {
-        h.t.Fatal("HTTP transport not configured")
-    }
-    u, err := url.Parse(h.httpSvr.URL)
-    if err != nil {
-        h.t.Fatalf("invalid test server URL: %v", err)
-    }
-    scheme := u.Scheme
-    host := u.Host
-    // Create WebSocket dialer for streaming endpoints
-    wsDialer := &websocket.Dialer{
-        Proxy: http.ProxyFromEnvironment,
-    }
-
-    return httpcli.NewClient(
-        scheme,
-        host,
-        h.httpCli,
-        goahttp.RequestEncoder,
-        goahttp.ResponseDecoder,
-        false,
-        wsDialer,
-        nil,
-    )
+	if h.httpSvr == nil || h.httpCli == nil {
+		h.t.Fatal("HTTP transport not configured")
+	}
+	u, err := url.Parse(h.httpSvr.URL)
+	if err != nil {
+		h.t.Fatalf("invalid test server URL: %v", err)
+	}
+	scheme := u.Scheme
+	host := u.Host
+	{{- if .HasStreams }}
+	// Create WebSocket dialer for streaming endpoints
+	wsDialer := &websocket.Dialer{
+		Proxy: http.ProxyFromEnvironment,
+	}
+	{{- end }}
+
+	return httpcli.NewClient(
+		scheme,
+		host,
+		h.httpCli,
+		goahttp.RequestEncoder,
+		goahttp.ResponseDecoder,
+		false,
+		{{- if .HasStreams }}
+		wsDialer,
+		nil,
+		{{- end }}
+	)
 }
 
 {{ printf "HTTPClientEndpoints creates HTTP client endpoints for the service." | comment }}
 func (h *Harness) HTTPClientEndpoints() *{{ .PkgName }}.Endpoints {
-    c := h.getHTTPClientImpl()
-    return &{{ .PkgName }}.Endpoints{
-        {{- range .Methods }}
-        {{- $method := . }}
-        {{- range .Targets }}
-        {{- if or .IsHTTPPlain .IsHTTPServerSent .IsHTTPWebSocket }}
-        {{ $method.VarName }}: c.{{ $method.VarName }}(),
-        {{- break }}
-        {{- end }}
-        {{- end }}
-        {{- end }}
-    }
+	c := h.getHTTPClientImpl()
+	return &{{ .PkgName }}.Endpoints{
+		{{- range .Methods }}
+		{{- $method := . }}
+		{{- range .Targets }}
+		{{- if or .IsHTTPPlain .IsHTTPServerSent .IsHTTPWebSocket }}
+		{{ $method.VarName }}: c.{{ $method.VarName }}(),
+		{{- break }}
+		{{- end }}
+		{{- end }}
+		{{- end }}
+	}
 }
 
 {{ printf "HTTPURL returns the base URL of the test HTTP server." | comment }}
@@ -108,6 +114,7 @@ func (h *Harness) HTTPRequest(method, path string, body any) *http.Request {
 	return req
 }
 
+{{- if .HasStreams }}
 {{ printf "HTTPWSURL builds a websocket URL from the base HTTP URL and path." | comment }}
 func (h *Harness) HTTPWSURL(path string) string {
 	base := h.HTTPURL()
@@ -123,6 +130,7 @@ func (h *Harness) HTTPWSURL(path string) string {
 	u.Path = path
 	return u.String()
 }
+{{- end }}
 
 {{ printf "HTTPDo performs an HTTP request and returns the response." | comment }}
 func (h *Harness) HTTPDo(req *http.Request) *http.Response {