grpc/tools/http2_interop/http2interop_test.go

package http2interop

import (
	"crypto/tls"
	"crypto/x509"
	"encoding/json"
	"flag"
	"fmt"
	"io/ioutil"
	"os"
	"strconv"
	"strings"
	"testing"
)

var (
	serverHost = flag.String("server_host", "", "The host to test")
	serverPort = flag.Int("server_port", 443, "The port to test")
	useTls     = flag.Bool("use_tls", true, "Should TLS tests be run")
	testCase   = flag.String("test_case", "", "What test cases to run (tls, framing)")

	// The rest of these are unused, but present to fulfill the client interface
	serverHostOverride    = flag.String("server_host_override", "", "Unused")
	useTestCa             = flag.Bool("use_test_ca", false, "Unused")
	defaultServiceAccount = flag.String("default_service_account", "", "Unused")
	oauthScope            = flag.String("oauth_scope", "", "Unused")
	serviceAccountKeyFile = flag.String("service_account_key_file", "", "Unused")
)

func InteropCtx(t *testing.T) *HTTP2InteropCtx {
	ctx := &HTTP2InteropCtx{
		ServerHost:             *serverHost,
		ServerPort:             *serverPort,
		ServerHostnameOverride: *serverHostOverride,
		UseTLS:                 *useTls,
		UseTestCa:              *useTestCa,
		T:                      t,
	}

	ctx.serverSpec = ctx.ServerHost
	if ctx.ServerPort != -1 {
		ctx.serverSpec += ":" + strconv.Itoa(ctx.ServerPort)
	}
	if ctx.ServerHostnameOverride == "" {
		ctx.authority = ctx.ServerHost
	} else {
		ctx.authority = ctx.ServerHostnameOverride
	}

	if ctx.UseTestCa {
		// It would be odd if useTestCa was true, but not useTls.  meh
		certData, err := ioutil.ReadFile("src/core/tsi/test_creds/ca.pem")
		if err != nil {
			t.Fatal(err)
		}

		ctx.rootCAs = x509.NewCertPool()
		if !ctx.rootCAs.AppendCertsFromPEM(certData) {
			t.Fatal(fmt.Errorf("Unable to parse pem data"))
		}
	}

	return ctx
}

func (ctx *HTTP2InteropCtx) Close() error {
	// currently a noop
	return nil
}

func TestSoonClientShortSettings(t *testing.T) {
	defer Report(t)
	if *testCase != "framing" {
		t.SkipNow()
	}
	ctx := InteropCtx(t)
	for i := 1; i <= 5; i++ {
		err := testClientShortSettings(ctx, i)
		matchError(t, err, "EOF")
	}
}

func TestSoonShortPreface(t *testing.T) {
	defer Report(t)
	if *testCase != "framing" {
		t.SkipNow()
	}
	ctx := InteropCtx(t)
	for i := 0; i < len(Preface)-1; i++ {
		err := testShortPreface(ctx, Preface[:i]+"X")
		matchError(t, err, "EOF")
	}
}

func TestSoonUnknownFrameType(t *testing.T) {
	defer Report(t)
	if *testCase != "framing" {
		t.SkipNow()
	}
	ctx := InteropCtx(t)
	if err := testUnknownFrameType(ctx); err != nil {
		t.Fatal(err)
	}
}

func TestSoonClientPrefaceWithStreamId(t *testing.T) {
	defer Report(t)
	if *testCase != "framing" {
		t.SkipNow()
	}
	ctx := InteropCtx(t)
	err := testClientPrefaceWithStreamId(ctx)
	matchError(t, err, "EOF")
}

func TestSoonTLSApplicationProtocol(t *testing.T) {
	defer Report(t)
	if *testCase != "tls" {
		t.SkipNow()
	}
	ctx := InteropCtx(t)
	err := testTLSApplicationProtocol(ctx)
	matchError(t, err, "EOF", "broken pipe")
}

func TestSoonTLSMaxVersion(t *testing.T) {
	defer Report(t)
	if *testCase != "tls" {
		t.SkipNow()
	}
	ctx := InteropCtx(t)
	err := testTLSMaxVersion(ctx, tls.VersionTLS11)
	// TODO(carl-mastrangelo): maybe this should be some other error.  If the server picks
	// the wrong protocol version, thats bad too.
	matchError(t, err, "EOF", "server selected unsupported protocol")
}

func TestSoonTLSBadCipherSuites(t *testing.T) {
	defer Report(t)
	if *testCase != "tls" {
		t.SkipNow()
	}
	ctx := InteropCtx(t)
	err := testTLSBadCipherSuites(ctx)
	matchError(t, err, "EOF", "Got goaway frame")
}

func matchError(t *testing.T, err error, matches ...string) {
	if err == nil {
		t.Fatal("Expected an error")
	}
	for _, s := range matches {
		if strings.Contains(err.Error(), s) {
			return
		}
	}
	t.Fatalf("Error %v not in %+v", err, matches)
}

func TestMain(m *testing.M) {
	flag.Parse()
	m.Run()
	var fatal bool
	var any bool
	for _, ci := range allCaseInfos.Cases {
		if ci.Skipped {
			continue
		}
		any = true
		if !ci.Passed && ci.Fatal {
			fatal = true
		}
	}

	if err := json.NewEncoder(os.Stderr).Encode(&allCaseInfos); err != nil {
		fmt.Println("Failed to encode", err)
	}
	var code int
	if !any || fatal {
		code = 1
	}
	os.Exit(code)
}