mirror of
https://github.com/hanzoai/porto.git
synced 2026-11-03 18:08:27 +00:00
669 lines
19 KiB
Go
669 lines
19 KiB
Go
package restserver_test
|
|
|
|
import (
|
|
"context"
|
|
"crypto/tls"
|
|
"crypto/x509"
|
|
"crypto/x509/pkix"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"os/signal"
|
|
"strings"
|
|
"syscall"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/effective-security/metrics"
|
|
"github.com/effective-security/porto/pkg/tlsconfig"
|
|
rest "github.com/effective-security/porto/restserver"
|
|
"github.com/effective-security/porto/restserver/authz"
|
|
"github.com/effective-security/porto/tests/testutils"
|
|
"github.com/effective-security/porto/xhttp/header"
|
|
"github.com/effective-security/porto/xhttp/identity"
|
|
"github.com/effective-security/porto/xhttp/marshal"
|
|
"github.com/pkg/errors"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
var tlsConnectionForAdmin = &tls.ConnectionState{
|
|
PeerCertificates: []*x509.Certificate{
|
|
{
|
|
Subject: pkix.Name{
|
|
CommonName: "Admin Trusted",
|
|
Organization: []string{"effective-security"},
|
|
},
|
|
},
|
|
},
|
|
VerifiedChains: [][]*x509.Certificate{
|
|
{
|
|
{
|
|
Subject: pkix.Name{
|
|
CommonName: "[TEST] Root CA",
|
|
Organization: []string{"effective-security"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
var tlsConnectionForAdminUntrusted = &tls.ConnectionState{
|
|
PeerCertificates: []*x509.Certificate{
|
|
{
|
|
Subject: pkix.Name{
|
|
CommonName: "Admin Untrusted",
|
|
Organization: []string{"effective-security"},
|
|
},
|
|
},
|
|
},
|
|
VerifiedChains: [][]*x509.Certificate{
|
|
{
|
|
{
|
|
Subject: pkix.Name{
|
|
CommonName: "[TEST] Untrusted Root CA",
|
|
Organization: []string{"effective-security"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
var tlsConnectionForClient = &tls.ConnectionState{
|
|
PeerCertificates: []*x509.Certificate{
|
|
{
|
|
Subject: pkix.Name{
|
|
CommonName: "Client User",
|
|
Organization: []string{"effective-security"},
|
|
},
|
|
},
|
|
},
|
|
VerifiedChains: [][]*x509.Certificate{
|
|
{
|
|
{
|
|
Subject: pkix.Name{
|
|
CommonName: "[TEST] Root CA",
|
|
Organization: []string{"effective-security"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
var tlsConnectionForClientFromOtherOrg = &tls.ConnectionState{
|
|
PeerCertificates: []*x509.Certificate{
|
|
{
|
|
Subject: pkix.Name{
|
|
CommonName: "Client Untrusted",
|
|
Organization: []string{"someorg"},
|
|
},
|
|
},
|
|
},
|
|
VerifiedChains: [][]*x509.Certificate{
|
|
{
|
|
{
|
|
Subject: pkix.Name{
|
|
CommonName: "[TEST] Root CA",
|
|
Organization: []string{"effective-security"},
|
|
},
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
func Test_NewServer(t *testing.T) {
|
|
cfg := &serverConfig{
|
|
BindAddr: testutils.CreateBindAddr(""),
|
|
}
|
|
|
|
server, err := rest.New("v1.0.123", "", cfg, nil)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, server)
|
|
|
|
if _, ok := interface{}(server).(rest.Server); !ok {
|
|
require.Fail(t, "ensure interface")
|
|
}
|
|
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, server.Version)
|
|
assert.NotNil(t, server.HostName)
|
|
assert.NotNil(t, server.LocalIP)
|
|
assert.NotNil(t, server.Port)
|
|
assert.NotNil(t, server.Protocol)
|
|
assert.NotNil(t, server.StartedAt)
|
|
assert.NotNil(t, server.Uptime)
|
|
assert.NotNil(t, server.Service)
|
|
assert.NotNil(t, server.IsReady)
|
|
assert.NotNil(t, server.AddService)
|
|
assert.NotNil(t, server.StartHTTP)
|
|
assert.NotNil(t, server.StopHTTP)
|
|
assert.NotNil(t, server.HTTPConfig)
|
|
assert.NotNil(t, server.OnEvent)
|
|
assert.NotEmpty(t, server.Version())
|
|
assert.NotEmpty(t, server.HostName())
|
|
assert.NotEmpty(t, server.LocalIP())
|
|
assert.NotEmpty(t, server.Port())
|
|
assert.Equal(t, "http", server.Protocol())
|
|
assert.NotNil(t, server.StartedAt())
|
|
assert.Nil(t, server.Service("abc"))
|
|
assert.False(t, server.IsReady())
|
|
assert.NotNil(t, server.HTTPConfig())
|
|
assert.Equal(t, cfg, server.HTTPConfig())
|
|
|
|
assert.Equal(t, fmt.Sprintf("http://%s:%s", server.HostName(), server.Port()), rest.GetServerBaseURL(server).String())
|
|
|
|
// assert.NotNil(t, server.AddService())
|
|
err = server.StartHTTP()
|
|
require.NoError(t, err)
|
|
|
|
for i := 0; i < 30 && !server.IsReady(); i++ {
|
|
time.Sleep(1 * time.Second)
|
|
}
|
|
require.True(t, server.IsReady())
|
|
|
|
server.StopHTTP()
|
|
}
|
|
|
|
func Test_NewServerWithGracefulShutdownSet(t *testing.T) {
|
|
cfg := &serverConfig{
|
|
BindAddr: testutils.CreateBindAddr("127.0.0.1"),
|
|
}
|
|
|
|
server, err := rest.New("v1.0.123", "", cfg, nil)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, server)
|
|
|
|
server.WithShutdownTimeout(time.Second * 5)
|
|
|
|
if _, ok := interface{}(server).(rest.Server); !ok {
|
|
require.Fail(t, "ensure interface")
|
|
}
|
|
|
|
require.NoError(t, err)
|
|
assert.NotNil(t, server.Version)
|
|
assert.NotNil(t, server.HostName)
|
|
assert.NotNil(t, server.LocalIP)
|
|
assert.NotNil(t, server.Port)
|
|
assert.NotNil(t, server.Protocol)
|
|
assert.NotNil(t, server.StartedAt)
|
|
assert.NotNil(t, server.Uptime)
|
|
assert.NotNil(t, server.Service)
|
|
assert.NotNil(t, server.IsReady)
|
|
assert.NotNil(t, server.AddService)
|
|
assert.NotNil(t, server.StartHTTP)
|
|
assert.NotNil(t, server.StopHTTP)
|
|
assert.NotNil(t, server.HTTPConfig)
|
|
assert.NotNil(t, server.OnEvent)
|
|
assert.NotEmpty(t, server.Version())
|
|
assert.NotEmpty(t, server.HostName())
|
|
assert.NotEmpty(t, server.LocalIP())
|
|
assert.NotEmpty(t, server.Port())
|
|
assert.Equal(t, "http", server.Protocol())
|
|
assert.NotNil(t, server.StartedAt())
|
|
assert.Nil(t, server.Service("abc"))
|
|
assert.False(t, server.IsReady())
|
|
assert.NotNil(t, server.HTTPConfig())
|
|
assert.Equal(t, cfg, server.HTTPConfig())
|
|
|
|
assert.Equal(t, fmt.Sprintf("%s://127.0.0.1:%s", server.Protocol(), server.Port()), rest.GetServerBaseURL(server).String())
|
|
|
|
// assert.NotNil(t, server.AddService())
|
|
err = server.StartHTTP()
|
|
require.NoError(t, err)
|
|
|
|
for i := 0; i < 30 && !server.IsReady(); i++ {
|
|
time.Sleep(1 * time.Second)
|
|
}
|
|
require.True(t, server.IsReady())
|
|
|
|
server.StopHTTP()
|
|
}
|
|
|
|
func Test_NewServerWithCustomHandler(t *testing.T) {
|
|
cfg := &serverConfig{
|
|
BindAddr: testutils.CreateBindAddr("127.0.0.1"),
|
|
}
|
|
|
|
server, err := rest.New("v1.0.123", "", cfg, nil)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, server)
|
|
svc := NewService(server)
|
|
server.AddService(svc)
|
|
|
|
defaultHandler := server.NewMux()
|
|
handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
ctx := context.WithValue(r.Context(), "test", "value in context")
|
|
r = r.WithContext(ctx)
|
|
defaultHandler.ServeHTTP(w, r)
|
|
})
|
|
server.WithMuxFactory(muxer(handler))
|
|
|
|
err = server.StartHTTP()
|
|
require.NoError(t, err)
|
|
|
|
for i := 0; i < 30 && !server.IsReady(); i++ {
|
|
time.Sleep(1 * time.Second)
|
|
}
|
|
require.True(t, server.IsReady())
|
|
|
|
url := fmt.Sprintf("%s://127.0.0.1:%s/v1/test", server.Protocol(), server.Port())
|
|
resp, err := http.Get(url)
|
|
require.NoError(t, err)
|
|
body, err := ioutil.ReadAll(resp.Body)
|
|
require.NoError(t, err)
|
|
require.Contains(t, string(body), "value in context")
|
|
|
|
sigs := make(chan os.Signal, 2)
|
|
go func() {
|
|
// Send STOP signal after few seconds,
|
|
// in production the service should listen to
|
|
// os.Interrupt, os.Kill, syscall.SIGTERM, syscall.SIGUSR2, syscall.SIGABRT events
|
|
time.Sleep(3 * time.Second)
|
|
fmt.Println("sending syscall.SIGTERM signal")
|
|
sigs <- syscall.SIGTERM
|
|
}()
|
|
|
|
// register for signals, and wait to be shutdown
|
|
signal.Notify(sigs, os.Interrupt, syscall.SIGTERM, syscall.SIGUSR2, syscall.SIGABRT)
|
|
// Block until a signal is received.
|
|
<-sigs
|
|
server.StopHTTP()
|
|
}
|
|
|
|
func Test_TLSConfig(t *testing.T) {
|
|
cfg := &serverConfig{
|
|
BindAddr: ":8081",
|
|
}
|
|
|
|
tlsConfig := &tls.Config{}
|
|
server, err := rest.New("v1.0.123", "", cfg, tlsConfig)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, server)
|
|
|
|
assert.NotNil(t, server.TLSConfig)
|
|
assert.Equal(t, tlsConfig, server.TLSConfig())
|
|
}
|
|
|
|
func Test_ResolveTCPAddr(t *testing.T) {
|
|
cfg := &serverConfig{
|
|
Name: "invalid",
|
|
BindAddr: "0-0-0-0",
|
|
}
|
|
|
|
server, err := rest.New("wrong", "", cfg, nil)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, server)
|
|
|
|
err = server.StartHTTP()
|
|
assert.EqualError(t, err, `unable to resolve address: address 0-0-0-0: missing port in address`)
|
|
}
|
|
|
|
func Test_GetServerURL(t *testing.T) {
|
|
cfg := &serverConfig{
|
|
BindAddr: "hostname:8081",
|
|
}
|
|
|
|
server, err := rest.New("wrong", "", cfg, nil)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, server)
|
|
|
|
t.Run("without XForwardedProto", func(t *testing.T) {
|
|
r, err := http.NewRequest(http.MethodGet, "/get/GET", nil)
|
|
require.NoError(t, err)
|
|
|
|
u := rest.GetServerURL(server, r, "/another/location")
|
|
require.NotNil(t, u)
|
|
|
|
assert.Equal(t, fmt.Sprintf("%s://%s/another/location", server.Protocol(), cfg.BindAddr), u.String())
|
|
})
|
|
|
|
t.Run("with XForwardedProto", func(t *testing.T) {
|
|
r, err := http.NewRequest(http.MethodGet, "/get/GET", nil)
|
|
require.NoError(t, err)
|
|
r.Header.Set(header.XForwardedProto, "https")
|
|
|
|
u := rest.GetServerURL(server, r, "/another/location")
|
|
require.NotNil(t, u)
|
|
|
|
assert.Equal(t, "https://hostname:8081/another/location", u.String())
|
|
})
|
|
|
|
t.Run("with XForwardedProto", func(t *testing.T) {
|
|
r, err := http.NewRequest(http.MethodGet, "/get/GET", nil)
|
|
require.NoError(t, err)
|
|
r.Header.Set(header.XForwardedProto, "https")
|
|
r.Host = "localhost"
|
|
|
|
u := rest.GetServerURL(server, r, "/another/location")
|
|
require.NotNil(t, u)
|
|
|
|
assert.Equal(t, "https://localhost/another/location", u.String())
|
|
})
|
|
}
|
|
|
|
type testMuxer struct {
|
|
handler http.Handler
|
|
}
|
|
|
|
func (tm *testMuxer) NewMux() http.Handler {
|
|
return tm.handler
|
|
}
|
|
|
|
func muxer(handler http.Handler) *testMuxer {
|
|
return &testMuxer{handler: handler}
|
|
}
|
|
|
|
type response struct {
|
|
Method string
|
|
Path string
|
|
}
|
|
|
|
func Test_Authz(t *testing.T) {
|
|
im := metrics.NewInmemSink(time.Minute, time.Minute)
|
|
_, err := metrics.NewGlobal(metrics.DefaultConfig("authztest"), im)
|
|
require.NoError(t, err)
|
|
|
|
defer func() {
|
|
md := im.Data()
|
|
if len(md) > 0 {
|
|
for k := range md[0].Gauges {
|
|
t.Log("Gauge:", k)
|
|
}
|
|
for k := range md[0].Counters {
|
|
t.Log("Counter:", k)
|
|
}
|
|
for k := range md[0].Samples {
|
|
t.Log("Sample:", k)
|
|
}
|
|
}
|
|
}()
|
|
|
|
assertSample := func(key string) {
|
|
md := im.Data()
|
|
require.NotEqual(t, 0, len(md))
|
|
|
|
_, exists := md[0].Samples[key]
|
|
assert.True(t, exists, "sample metric not found: %s", key)
|
|
}
|
|
assertCounter := func(key string, expectedCount int) {
|
|
md := im.Data()
|
|
require.NotEqual(t, 0, len(md))
|
|
|
|
s, exists := md[0].Counters[key]
|
|
if assert.True(t, exists, "counter metric not found: %s", key) {
|
|
assert.Equal(t, expectedCount, s.Count, "unexpected count for metric %s", key)
|
|
}
|
|
}
|
|
|
|
tlsCfg, err := tlsconfig.NewServerTLSFromFiles(
|
|
"testdata/test-server.pem",
|
|
"testdata/test-server-key.pem",
|
|
"testdata/test-server-rootca.pem",
|
|
tls.RequireAndVerifyClientCert,
|
|
)
|
|
require.NoError(t, err)
|
|
|
|
cfg := &serverConfig{
|
|
BindAddr: testutils.CreateBindAddr(""),
|
|
Services: []string{"authztest"},
|
|
}
|
|
authz, err := authz.New(&authz.Config{
|
|
Allow: []string{"/v1/allow:admin"},
|
|
AllowAny: []string{"/v1/allowany"},
|
|
AllowAnyRole: []string{"/v1/allowanyrole"},
|
|
LogAllowed: true,
|
|
LogDenied: true,
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
startServer := func(ready bool, idprov identity.ProviderFromRequest) (*rest.HTTPServer, *serviceX) {
|
|
cfg.BindAddr = testutils.CreateBindAddr("")
|
|
|
|
server, err := rest.New("v1.0.123", "127.0.0.1", cfg, tlsCfg)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, server)
|
|
server.WithAuthz(authz)
|
|
|
|
if idprov != nil {
|
|
server.WithIdentityProvider(idprov)
|
|
}
|
|
|
|
service := newService(t, server, "authztest", ready)
|
|
server.AddService(service)
|
|
|
|
err = server.StartHTTP()
|
|
require.NoError(t, err)
|
|
|
|
if ready {
|
|
for i := 0; i < 10 && !server.IsReady(); i++ {
|
|
time.Sleep(500 * time.Millisecond)
|
|
}
|
|
require.True(t, server.IsReady())
|
|
}
|
|
|
|
return server, service
|
|
}
|
|
|
|
t.Run("service not ready", func(t *testing.T) {
|
|
server, _ := startServer(false, nil)
|
|
defer server.StopHTTP()
|
|
|
|
assert.False(t, server.IsReady())
|
|
|
|
w := httptest.NewRecorder()
|
|
r, _ := http.NewRequest(http.MethodGet, "/v1/allowany", nil)
|
|
server.ServeHTTP(w, r)
|
|
|
|
//assert.NotEmpty(t, w.Header().Get(header.XHostname))
|
|
cid := w.Header().Get(header.XCorrelationID)
|
|
assert.NotEmpty(t, cid)
|
|
assert.Equal(t, http.StatusServiceUnavailable, w.Code)
|
|
assert.Equal(t, fmt.Sprintf(`{"code":"not_ready","request_id":"%s","message":"the service is not ready yet"}`, cid), w.Body.String())
|
|
})
|
|
|
|
t.Run("connection is not over TLS", func(t *testing.T) {
|
|
server, _ := startServer(true, nil)
|
|
defer server.StopHTTP()
|
|
|
|
assert.True(t, server.IsReady())
|
|
|
|
w := httptest.NewRecorder()
|
|
r, _ := http.NewRequest(http.MethodGet, "/v1/allowany", nil)
|
|
server.ServeHTTP(w, r)
|
|
|
|
//assert.NotEmpty(t, w.Header().Get(header.XHostname))
|
|
assert.NotEmpty(t, w.Header().Get(header.XCorrelationID))
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
})
|
|
|
|
t.Run("guest_to_allow_401", func(t *testing.T) {
|
|
server, _ := startServer(true, nil)
|
|
defer server.StopHTTP()
|
|
assert.True(t, server.IsReady())
|
|
|
|
w := httptest.NewRecorder()
|
|
r, _ := http.NewRequest(http.MethodGet, "/v1/allow", nil)
|
|
r.TLS = tlsConnectionForClient
|
|
server.ServeHTTP(w, r)
|
|
//assert.NotEmpty(t, w.Header().Get(header.XHostname))
|
|
cid := w.Header().Get(header.XCorrelationID)
|
|
assert.NotEmpty(t, cid)
|
|
assert.Equal(t, http.StatusUnauthorized, w.Code)
|
|
assert.Equal(t, fmt.Sprintf(`{"code":"unauthorized","request_id":"%s","message":"request %s: unauthorized: guest role not allowed"}`, cid, cid), w.Body.String())
|
|
assertSample("authztest_http_requests_perf;verb=GET;status=401;uri=/v1/allow")
|
|
assertCounter("authztest_http_requests_role;verb=GET;status=401;uri=/v1/allow;role=guest", 1)
|
|
})
|
|
|
|
t.Run("must_have_TLS", func(t *testing.T) {
|
|
server, _ := startServer(true, identityMapperFromCNMust)
|
|
defer server.StopHTTP()
|
|
assert.True(t, server.IsReady())
|
|
|
|
w := httptest.NewRecorder()
|
|
r, _ := http.NewRequest(http.MethodGet, "/v1/allow", nil)
|
|
server.ServeHTTP(w, r)
|
|
//assert.NotEmpty(t, w.Header().Get(header.XHostname))
|
|
assert.NotEmpty(t, w.Header().Get(header.XCorrelationID))
|
|
assert.Equal(t, http.StatusUnauthorized, w.Code)
|
|
|
|
assertSample("authztest_http_requests_perf;verb=GET;status=401;uri=/v1/allow")
|
|
assertCounter("authztest_http_requests_role;verb=GET;status=401;uri=/v1/allow;role=guest", 2)
|
|
})
|
|
|
|
server, _ := startServer(true, identityMapperFromCN)
|
|
defer server.StopHTTP()
|
|
assert.True(t, server.IsReady())
|
|
|
|
t.Run("admin_to_allow_200", func(t *testing.T) {
|
|
w := httptest.NewRecorder()
|
|
r, _ := http.NewRequest(http.MethodGet, "/v1/allow", nil)
|
|
r.TLS = tlsConnectionForAdmin
|
|
server.ServeHTTP(w, r)
|
|
//assert.NotEmpty(t, w.Header().Get(header.XHostname))
|
|
assert.NotEmpty(t, w.Header().Get(header.XCorrelationID))
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
assertCounter("authztest_http_requests_role;verb=GET;status=200;uri=/v1/allow;role=admin", 1)
|
|
assertSample("authztest_http_requests_perf;verb=GET;status=200;uri=/v1/allow")
|
|
})
|
|
|
|
t.Run("any_root_admin_to_allow_200", func(t *testing.T) {
|
|
w := httptest.NewRecorder()
|
|
r, _ := http.NewRequest(http.MethodGet, "/v1/allow", nil)
|
|
r.TLS = tlsConnectionForAdminUntrusted
|
|
server.ServeHTTP(w, r)
|
|
//assert.NotEmpty(t, w.Header().Get(header.XHostname))
|
|
assert.NotEmpty(t, w.Header().Get(header.XCorrelationID))
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
assert.Equal(t, `{"Method":"GET","Path":"/v1/allow"}`, w.Body.String())
|
|
|
|
assertSample("authztest_http_requests_perf;verb=GET;status=401;uri=/v1/allow")
|
|
assertCounter("authztest_http_requests_role;verb=GET;status=401;uri=/v1/allow;role=guest", 2)
|
|
})
|
|
|
|
t.Run("client_to_allow_401", func(t *testing.T) {
|
|
w := httptest.NewRecorder()
|
|
r, _ := http.NewRequest(http.MethodGet, "/v1/allow", nil)
|
|
r.TLS = tlsConnectionForClient
|
|
server.ServeHTTP(w, r)
|
|
//assert.NotEmpty(t, w.Header().Get(header.XHostname))
|
|
cid := w.Header().Get(header.XCorrelationID)
|
|
assert.NotEmpty(t, cid)
|
|
assert.Equal(t, http.StatusUnauthorized, w.Code)
|
|
assert.Equal(t, fmt.Sprintf(`{"code":"unauthorized","request_id":"%s","message":"request %s: unauthorized: client role not allowed"}`, cid, cid), w.Body.String())
|
|
assertSample("authztest_http_requests_perf;verb=GET;status=401;uri=/v1/allow")
|
|
assertCounter("authztest_http_requests_role;verb=GET;status=401;uri=/v1/allow;role=guest", 2)
|
|
})
|
|
|
|
t.Run("other_org_client_to_allow_401", func(t *testing.T) {
|
|
w := httptest.NewRecorder()
|
|
r, _ := http.NewRequest(http.MethodGet, "/v1/allow", nil)
|
|
r.TLS = tlsConnectionForClientFromOtherOrg
|
|
server.ServeHTTP(w, r)
|
|
//assert.NotEmpty(t, w.Header().Get(header.XHostname))
|
|
cid := w.Header().Get(header.XCorrelationID)
|
|
assert.NotEmpty(t, cid)
|
|
assert.Equal(t, http.StatusUnauthorized, w.Code)
|
|
assert.Equal(t, fmt.Sprintf(`{"code":"unauthorized","request_id":"%s","message":"request %s: unauthorized: client role not allowed"}`, cid, cid), w.Body.String())
|
|
assertSample("authztest_http_requests_perf;verb=GET;status=401;uri=/v1/allow")
|
|
assertCounter("authztest_http_requests_role;verb=GET;status=401;uri=/v1/allow;role=guest", 2)
|
|
})
|
|
|
|
t.Run("client_to_allowany_200", func(t *testing.T) {
|
|
w := httptest.NewRecorder()
|
|
r, _ := http.NewRequest(http.MethodGet, "/v1/allowany", nil)
|
|
r.TLS = tlsConnectionForClient
|
|
server.ServeHTTP(w, r)
|
|
//assert.NotEmpty(t, w.Header().Get(header.XHostname))
|
|
assert.NotEmpty(t, w.Header().Get(header.XCorrelationID))
|
|
assert.Equal(t, http.StatusOK, w.Code)
|
|
|
|
assertCounter("authztest_http_requests_role;verb=GET;status=200;uri=/v1/allowany;role=client", 1)
|
|
assertSample("authztest_http_requests_perf;verb=GET;status=200;uri=/v1/allowany")
|
|
})
|
|
}
|
|
|
|
func identityMapperFromCN(r *http.Request) (identity.Identity, error) {
|
|
var role string
|
|
var name string
|
|
if r.TLS == nil || len(r.TLS.PeerCertificates) == 0 {
|
|
name = identity.ClientIPFromRequest(r)
|
|
role = identity.GuestRoleName
|
|
} else {
|
|
name = r.TLS.PeerCertificates[0].Subject.CommonName
|
|
role = "user"
|
|
|
|
if strings.Contains(name, "Admin") {
|
|
role = "admin"
|
|
} else if strings.Contains(name, "Client") {
|
|
role = "client"
|
|
}
|
|
|
|
}
|
|
return identity.NewIdentity(role, name, "", nil, "", ""), nil
|
|
}
|
|
|
|
func identityMapperFromCNMust(r *http.Request) (identity.Identity, error) {
|
|
if r.TLS == nil || len(r.TLS.PeerCertificates) == 0 {
|
|
return nil, errors.New("missing client certificate")
|
|
}
|
|
return identity.NewIdentity("user", r.TLS.PeerCertificates[0].Subject.CommonName, "", nil, "", ""), nil
|
|
}
|
|
|
|
type serviceX struct {
|
|
t *testing.T
|
|
server rest.Server
|
|
name string
|
|
ready bool
|
|
}
|
|
|
|
// newService returns ane instances of the Status service
|
|
func newService(t *testing.T, server rest.Server, name string, ready bool) *serviceX {
|
|
svc := &serviceX{
|
|
t: t,
|
|
server: server,
|
|
name: name,
|
|
ready: ready,
|
|
}
|
|
return svc
|
|
}
|
|
|
|
func (s *serviceX) setReady() {
|
|
s.ready = true
|
|
}
|
|
|
|
// Name returns the service name
|
|
func (s *serviceX) Name() string {
|
|
return s.name
|
|
}
|
|
|
|
// IsReady indicates that the service is ready to serve its end-points
|
|
func (s *serviceX) IsReady() bool {
|
|
return s.ready
|
|
}
|
|
|
|
// Close the subservices and it's resources
|
|
func (s *serviceX) Close() {
|
|
}
|
|
|
|
// Register adds the server Status API endpoints to the overall URL router
|
|
func (s *serviceX) Register(r rest.Router) {
|
|
r.GET("/v1/allow", s.handle())
|
|
r.GET("/v1/allowany", s.handle())
|
|
r.GET("/v1/allowanyrole", s.handle())
|
|
}
|
|
|
|
func (s *serviceX) handle() rest.Handle {
|
|
return func(w http.ResponseWriter, r *http.Request, _ rest.Params) {
|
|
s.t.Logf("serviceX: %s %s", r.Method, r.URL.Path)
|
|
res := &response{
|
|
Method: r.Method,
|
|
Path: r.URL.Path,
|
|
}
|
|
|
|
marshal.WriteJSON(w, r, res)
|
|
}
|
|
}
|