github.com/weaveworks/common@v0.0.0-20230728070032-dd9e68f319d5/httpgrpc/server/server_test.go (about)

     1  package server
     2  
     3  import (
     4  	"bytes"
     5  	"context"
     6  	"fmt"
     7  	"net"
     8  	"net/http"
     9  	"net/http/httptest"
    10  	"testing"
    11  
    12  	opentracing "github.com/opentracing/opentracing-go"
    13  	"github.com/stretchr/testify/assert"
    14  	"github.com/stretchr/testify/require"
    15  	jaegercfg "github.com/uber/jaeger-client-go/config"
    16  	"google.golang.org/grpc"
    17  
    18  	"github.com/weaveworks/common/httpgrpc"
    19  	"github.com/weaveworks/common/middleware"
    20  	"github.com/weaveworks/common/user"
    21  )
    22  
    23  type testServer struct {
    24  	*Server
    25  	URL        string
    26  	grpcServer *grpc.Server
    27  }
    28  
    29  func newTestServer(handler http.Handler) (*testServer, error) {
    30  	lis, err := net.Listen("tcp", "127.0.0.1:0")
    31  	if err != nil {
    32  		return nil, err
    33  	}
    34  
    35  	server := &testServer{
    36  		Server:     NewServer(handler),
    37  		grpcServer: grpc.NewServer(),
    38  		URL:        "direct://" + lis.Addr().String(),
    39  	}
    40  
    41  	httpgrpc.RegisterHTTPServer(server.grpcServer, server.Server)
    42  	go server.grpcServer.Serve(lis)
    43  
    44  	return server, nil
    45  }
    46  
    47  func TestBasic(t *testing.T) {
    48  	server, err := newTestServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    49  		fmt.Fprint(w, "world")
    50  	}))
    51  	require.NoError(t, err)
    52  	defer server.grpcServer.GracefulStop()
    53  
    54  	client, err := NewClient(server.URL)
    55  	require.NoError(t, err)
    56  
    57  	req, err := http.NewRequest("GET", "/hello", &bytes.Buffer{})
    58  	require.NoError(t, err)
    59  
    60  	req = req.WithContext(user.InjectOrgID(context.Background(), "1"))
    61  	recorder := httptest.NewRecorder()
    62  	client.ServeHTTP(recorder, req)
    63  
    64  	assert.Equal(t, "world", recorder.Body.String())
    65  	assert.Equal(t, 200, recorder.Code)
    66  }
    67  
    68  func TestError(t *testing.T) {
    69  	server, err := newTestServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    70  		// Does a Fprintln, injecting a newline.
    71  		http.Error(w, "foo", http.StatusInternalServerError)
    72  	}))
    73  	require.NoError(t, err)
    74  	defer server.grpcServer.GracefulStop()
    75  
    76  	client, err := NewClient(server.URL)
    77  	require.NoError(t, err)
    78  
    79  	req, err := http.NewRequest("GET", "/hello", &bytes.Buffer{})
    80  	require.NoError(t, err)
    81  
    82  	req = req.WithContext(user.InjectOrgID(context.Background(), "1"))
    83  	recorder := httptest.NewRecorder()
    84  	client.ServeHTTP(recorder, req)
    85  
    86  	assert.Equal(t, "foo\n", recorder.Body.String())
    87  	assert.Equal(t, 500, recorder.Code)
    88  }
    89  
    90  func TestParseURL(t *testing.T) {
    91  	for _, tc := range []struct {
    92  		input    string
    93  		expected string
    94  		err      string
    95  	}{
    96  		{"direct://foo", "foo", ""},
    97  		{"kubernetes://foo:123", "kubernetes:///foo:123", ""},
    98  		{"querier.cortex:995", "kubernetes:///querier.cortex:995", ""},
    99  		{"foo.bar.svc.local:995", "kubernetes:///foo.bar.svc.local:995", ""},
   100  		{"kubernetes:///foo:123", "kubernetes:///foo:123", ""},
   101  		{"dns:///foo.bar.svc.local:995", "dns:///foo.bar.svc.local:995", ""},
   102  		{"monster://foo:995", "", "unrecognised scheme: monster"},
   103  	} {
   104  		got, err := ParseURL(tc.input)
   105  		if tc.err == "" {
   106  			require.NoError(t, err)
   107  		} else {
   108  			require.EqualError(t, err, tc.err)
   109  		}
   110  		assert.Equal(t, tc.expected, got)
   111  	}
   112  }
   113  
   114  func TestTracePropagation(t *testing.T) {
   115  	jaeger := jaegercfg.Configuration{}
   116  	closer, err := jaeger.InitGlobalTracer("test")
   117  	require.NoError(t, err)
   118  	defer closer.Close()
   119  
   120  	server, err := newTestServer(middleware.Tracer{}.Wrap(
   121  		http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
   122  			span := opentracing.SpanFromContext(r.Context())
   123  			fmt.Fprint(w, span.BaggageItem("name"))
   124  		}),
   125  	))
   126  
   127  	require.NoError(t, err)
   128  	defer server.grpcServer.GracefulStop()
   129  
   130  	client, err := NewClient(server.URL)
   131  	require.NoError(t, err)
   132  
   133  	req, err := http.NewRequest("GET", "/hello", &bytes.Buffer{})
   134  	require.NoError(t, err)
   135  
   136  	sp, ctx := opentracing.StartSpanFromContext(context.Background(), "Test")
   137  	sp.SetBaggageItem("name", "world")
   138  
   139  	req = req.WithContext(user.InjectOrgID(ctx, "1"))
   140  	recorder := httptest.NewRecorder()
   141  	client.ServeHTTP(recorder, req)
   142  
   143  	assert.Equal(t, "world", recorder.Body.String())
   144  	assert.Equal(t, 200, recorder.Code)
   145  }