Skip to content

SigNoz is an open-source, OpenTelemetry-native observability platform for your team and their AI agents. Get logs, metrics, and traces in one tool with features like APM, distributed tracing, log management, infra monitoring, etc. Combined with SigNoz MCP and a native AI teammate (in SigNoz Cloud) it helps you build more resilient apps.

6.7 KB
Raw Blame
package routerweb

import (
	"context"
	"encoding/json"
	"io"
	"net"
	"net/http"
	"net/url"
	"os"
	"path/filepath"
	"strings"
	"testing"

	"github.com/SigNoz/signoz/pkg/factory/factorytest"
	"github.com/SigNoz/signoz/pkg/global"
	"github.com/SigNoz/signoz/pkg/web"
	"github.com/gorilla/mux"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

func expectedHTML(baseHref string, settings web.Settings) string {
	settingsJSON, _ := json.Marshal(settings)
	return `<html><head><base href="` + baseHref + `" /></head><body><script>window.signozBootData={settings:` + string(settingsJSON) + `}</script>Welcome to test data!!!</body></html>`
}

func startServer(t *testing.T, config web.Config, globalConfig global.Config) string {
	t.Helper()

	web, err := New(context.Background(), factorytest.NewSettings(), config, globalConfig)
	require.NoError(t, err)

	router := mux.NewRouter()
	require.NoError(t, web.AddToRouter(router))

	listener, err := net.Listen("tcp", "localhost:0")
	require.NoError(t, err)

	server := &http.Server{Handler: router}
	go func() { _ = server.Serve(listener) }()
	t.Cleanup(func() { _ = server.Close() })

	return "http://" + listener.Addr().String()
}

func httpGet(t *testing.T, url string) string {
	t.Helper()

	res, err := http.DefaultClient.Get(url)
	require.NoError(t, err)
	defer func() { _ = res.Body.Close() }()

	body, err := io.ReadAll(res.Body)
	require.NoError(t, err)

	return string(body)
}

func TestServeTemplatedIndex(t *testing.T) {
	t.Parallel()

	emptySettings := web.Settings{}

	testCases := []struct {
		name         string
		path         string
		globalConfig global.Config
		webConfig    web.Config
		expected     string
	}{
		{
			name:         "RootBaseHrefAtRoot",
			path:         "/",
			globalConfig: global.Config{},
			webConfig:    web.Config{Index: "valid_template.html", Directory: "testdata"},
			expected:     expectedHTML("/", emptySettings),
		},
		{
			name:         "RootBaseHrefAtNonExistentPath",
			path:         "/does-not-exist",
			globalConfig: global.Config{},
			webConfig:    web.Config{Index: "valid_template.html", Directory: "testdata"},
			expected:     expectedHTML("/", emptySettings),
		},
		{
			name:         "RootBaseHrefAtDirectory",
			path:         "/assets",
			globalConfig: global.Config{},
			webConfig:    web.Config{Index: "valid_template.html", Directory: "testdata"},
			expected:     expectedHTML("/", emptySettings),
		},
		{
			name:         "SubPathBaseHrefAtRoot",
			path:         "/",
			globalConfig: global.Config{ExternalURL: &url.URL{Scheme: "https", Host: "example.com", Path: "/signoz"}},
			webConfig:    web.Config{Index: "valid_template.html", Directory: "testdata"},
			expected:     expectedHTML("/signoz/", emptySettings),
		},
		{
			name:         "SubPathBaseHrefAtNonExistentPath",
			path:         "/does-not-exist",
			globalConfig: global.Config{ExternalURL: &url.URL{Scheme: "https", Host: "example.com", Path: "/signoz"}},
			webConfig:    web.Config{Index: "valid_template.html", Directory: "testdata"},
			expected:     expectedHTML("/signoz/", emptySettings),
		},
		{
			name:         "SubPathBaseHrefAtDirectory",
			path:         "/assets",
			globalConfig: global.Config{ExternalURL: &url.URL{Scheme: "https", Host: "example.com", Path: "/signoz"}},
			webConfig:    web.Config{Index: "valid_template.html", Directory: "testdata"},
			expected:     expectedHTML("/signoz/", emptySettings),
		},
		{
			name:         "WithPopulatedSettings",
			path:         "/",
			globalConfig: global.Config{},
			webConfig: web.Config{
				Index:     "valid_template.html",
				Directory: "testdata",
				Settings: web.SettingsConfig{
					Posthog: web.PosthogConfig{
						Enabled: true,
						Key:     "phc_examplekey",
						APIHost: "https://us.i.posthog.com",
						UIHost:  "https://us.posthog.com",
					},
					Appcues: web.AppcuesConfig{
						Enabled: true,
						AppID:   "12345-abcde",
					},
					Sentry: web.SentryConfig{
						Enabled: true,
						DSN:     "https://[email protected]/0",
						Tunnel:  "https://example.com/tunnel",
					},
					Pylon: web.PylonConfig{
						Enabled:        true,
						AppID:          "pylon-app-id",
						IdentitySecret: "pylon-secret",
					},
				},
			},
			expected: expectedHTML("/", web.Settings{
				Posthog: web.Posthog{
					Enabled: true,
					Key:     "phc_examplekey",
					APIHost: "https://us.i.posthog.com",
					UIHost:  "https://us.posthog.com",
				},
				Appcues: web.Appcues{
					Enabled: true,
					AppID:   "12345-abcde",
				},
				Sentry: web.Sentry{
					Enabled: true,
					DSN:     "https://[email protected]/0",
					Tunnel:  "https://example.com/tunnel",
				},
				Pylon: web.Pylon{
					Enabled:        true,
					AppID:          "pylon-app-id",
					IdentitySecret: "pylon-secret",
				},
			}),
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			base := startServer(t, testCase.webConfig, testCase.globalConfig)

			assert.Equal(t, testCase.expected, strings.TrimSuffix(httpGet(t, base+testCase.path), "\n"))
		})
	}
}

func TestServeNoTemplateIndex(t *testing.T) {
	t.Parallel()

	expected, err := os.ReadFile(filepath.Join("testdata", "no_template.html"))
	require.NoError(t, err)

	testCases := []struct {
		name string
		path string
	}{
		{
			name: "Root",
			path: "/",
		},
		{
			name: "NonExistentPath",
			path: "/does-not-exist",
		},
		{
			name: "Directory",
			path: "/assets",
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			base := startServer(t, web.Config{Index: "no_template.html", Directory: "testdata"}, global.Config{})

			assert.Equal(t, string(expected), httpGet(t, base+testCase.path))
		})
	}
}

func TestServeInvalidTemplateIndex(t *testing.T) {
	t.Parallel()

	expected, err := os.ReadFile(filepath.Join("testdata", "invalid_template.html"))
	require.NoError(t, err)

	testCases := []struct {
		name string
		path string
	}{
		{
			name: "Root",
			path: "/",
		},
		{
			name: "NonExistentPath",
			path: "/does-not-exist",
		},
		{
			name: "Directory",
			path: "/assets",
		},
	}

	for _, testCase := range testCases {
		t.Run(testCase.name, func(t *testing.T) {
			base := startServer(t, web.Config{Index: "invalid_template.html", Directory: "testdata"}, global.Config{ExternalURL: &url.URL{Path: "/signoz"}})

			assert.Equal(t, string(expected), httpGet(t, base+testCase.path))
		})
	}
}

func TestServeStaticFilesUnchanged(t *testing.T) {
	t.Parallel()

	expected, err := os.ReadFile(filepath.Join("testdata", "assets", "style.css"))
	require.NoError(t, err)

	base := startServer(t, web.Config{Index: "valid_template.html", Directory: "testdata"}, global.Config{ExternalURL: &url.URL{Path: "/signoz"}})

	assert.Equal(t, string(expected), httpGet(t, base+"/assets/style.css"))
}