Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

10.7 KB
Raw Blame
package enterprise

import (
	"context"
	"crypto/rand"
	"crypto/rsa"
	"crypto/x509"
	"encoding/pem"
	"math"
	"testing"
	"time"

	"github.com/bytebase/bytebase/backend/common/testcontainer"

	"github.com/golang-jwt/jwt/v5"
	"github.com/hashicorp/golang-lru/v2/expirable"
	"github.com/stretchr/testify/require"

	"github.com/bytebase/bytebase/backend/common"
	storepb "github.com/bytebase/bytebase/backend/generated-go/store"
	v1pb "github.com/bytebase/bytebase/backend/generated-go/v1"
	"github.com/bytebase/bytebase/backend/store"
)

func newTestLicenseService(sub *v1pb.Subscription) *LicenseService {
	s := &LicenseService{
		cache: expirable.NewLRU[string, *v1pb.Subscription](8, nil, time.Minute),
	}
	s.cache.Add(licenseCacheKey("test-workspace"), sub)
	return s
}

func TestIsUnifiedInstanceLimit(t *testing.T) {
	tests := []struct {
		name           string
		instanceLimit  int
		activatedLimit int
		want           bool
	}{
		{name: "equal finite caps", instanceLimit: 10, activatedLimit: 10, want: true},
		{name: "activated cap larger than registration cap", instanceLimit: 10, activatedLimit: 20, want: true},
		{name: "split cap", instanceLimit: 50, activatedLimit: 20, want: false},
		{name: "unlimited both sides", instanceLimit: math.MaxInt, activatedLimit: math.MaxInt, want: true},
		{name: "unlimited registration finite activation", instanceLimit: math.MaxInt, activatedLimit: 20, want: false},
		{name: "finite registration unlimited activation", instanceLimit: 20, activatedLimit: math.MaxInt, want: true},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if got := isUnifiedInstanceLimit(tt.instanceLimit, tt.activatedLimit); got != tt.want {
				t.Fatalf("isUnifiedInstanceLimit(%d, %d) = %v, want %v", tt.instanceLimit, tt.activatedLimit, got, tt.want)
			}
		})
	}
}

func TestIsFeatureEnabledForInstanceUnifiedLicense(t *testing.T) {
	ctx := context.Background()
	instance := &store.InstanceMessage{
		ResourceID: "prod",
		Workspace:  "test-workspace",
		Metadata:   &storepb.Instance{Activation: false},
	}
	service := newTestLicenseService(&v1pb.Subscription{
		Plan:            v1pb.PlanType_ENTERPRISE,
		Instances:       10,
		ActiveInstances: 10,
	})

	if err := service.IsFeatureEnabledForInstance(ctx, "test-workspace", v1pb.PlanFeature_FEATURE_DATA_MASKING, instance); err != nil {
		t.Fatalf("unified license should enable feature for inactive stored instance: %v", err)
	}
}

func TestIsFeatureEnabledForInstanceSplitLicense(t *testing.T) {
	ctx := context.Background()
	instance := &store.InstanceMessage{
		ResourceID: "prod",
		Workspace:  "test-workspace",
		Metadata:   &storepb.Instance{Activation: false},
	}
	service := newTestLicenseService(&v1pb.Subscription{
		Plan:            v1pb.PlanType_ENTERPRISE,
		Instances:       50,
		ActiveInstances: 20,
	})

	if err := service.IsFeatureEnabledForInstance(ctx, "test-workspace", v1pb.PlanFeature_FEATURE_DATA_MASKING, instance); err == nil {
		t.Fatal("split license should still require stored activation")
	}
}

func TestIsInstanceEffectivelyActivated(t *testing.T) {
	ctx := context.Background()
	instance := &store.InstanceMessage{
		ResourceID: "prod",
		Workspace:  "test-workspace",
		Metadata:   &storepb.Instance{Activation: false},
	}

	unifiedService := newTestLicenseService(&v1pb.Subscription{
		Plan:            v1pb.PlanType_ENTERPRISE,
		Instances:       10,
		ActiveInstances: 10,
	})
	if !unifiedService.IsInstanceEffectivelyActivated(ctx, "test-workspace", instance) {
		t.Fatal("unified license should effectively activate stored inactive instance")
	}

	splitService := newTestLicenseService(&v1pb.Subscription{
		Plan:            v1pb.PlanType_ENTERPRISE,
		Instances:       50,
		ActiveInstances: 20,
	})
	if splitService.IsInstanceEffectivelyActivated(ctx, "test-workspace", instance) {
		t.Fatal("split license should use stored inactive state")
	}

	instance.Metadata.Activation = true
	if !splitService.IsInstanceEffectivelyActivated(ctx, "test-workspace", instance) {
		t.Fatal("split license should keep stored active state")
	}
}

func TestCreateLicenseUsesEqualInstanceClaims(t *testing.T) {
	claims := newLicenseClaims(&LicenseParams{
		Plan:        v1pb.PlanType_ENTERPRISE.String(),
		Seats:       5,
		Instances:   10,
		WorkspaceID: "test-workspace",
	})
	if claims.Instances != 10 {
		t.Fatalf("Instances = %d, want 10", claims.Instances)
	}
	if claims.ActiveInstances != 10 {
		t.Fatalf("ActiveInstances = %d, want 10", claims.ActiveInstances)
	}
}

func TestNewLicenseClaimsPropagatesTrialing(t *testing.T) {
	trial := newLicenseClaims(&LicenseParams{Plan: v1pb.PlanType_TEAM.String(), Trialing: true})
	require.True(t, trial.Trialing)

	paid := newLicenseClaims(&LicenseParams{Plan: v1pb.PlanType_TEAM.String()})
	require.False(t, paid.Trialing)
}

func TestParseLicenseExpiredIsInvalid(t *testing.T) {
	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
	require.NoError(t, err)
	service := &LicenseService{
		config: &Config{
			PublicKey:  &privateKey.PublicKey,
			PrivateKey: privateKey,
			Version:    keyID,
			Issuer:     issuer,
			Audience:   audience,
		},
	}
	license, err := service.CreateLicense(&LicenseParams{
		Plan:      v1pb.PlanType_TEAM.String(),
		ExpiresAt: time.Now().Add(-time.Hour),
	})
	require.NoError(t, err)

	err = service.validateLicense(license, "test-workspace")
	require.Equal(t, common.Invalid, common.ErrorCode(err))
}

func TestLoadSubscriptionFromDB(t *testing.T) {
	ctx, cancel := context.WithTimeout(context.Background(), 60*time.Second)
	t.Cleanup(cancel)
	_, stores, _ := testcontainer.NewMetadataDBWithCache(t, true)

	_, err := stores.GetDB().ExecContext(ctx, `INSERT INTO workspace (resource_id) VALUES ('default')`)
	require.NoError(t, err)
	_, err = stores.UpsertSetting(ctx, &store.SettingMessage{
		Name:      storepb.SettingName_SYSTEM,
		Workspace: "default",
		Value:     &storepb.SystemSetting{},
	})
	require.NoError(t, err)

	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
	require.NoError(t, err)
	service := &LicenseService{
		store: stores,
		config: &Config{
			PublicKey:  &privateKey.PublicKey,
			PrivateKey: privateKey,
			Version:    keyID,
			Issuer:     issuer,
			Audience:   audience,
		},
		cache: expirable.NewLRU[string, *v1pb.Subscription](8, nil, time.Minute),
	}

	stored, err := service.LoadSubscriptionFromDB(ctx, "default")
	require.NoError(t, err)
	require.Nil(t, stored)
	require.Equal(t, v1pb.PlanType_FREE, service.LoadEffectiveSubscription(ctx, "default").Plan)

	expiresAt := time.Now().Add(-time.Hour).UTC().Truncate(time.Second)
	license, err := service.CreateLicense(&LicenseParams{
		Plan:        v1pb.PlanType_TEAM.String(),
		WorkspaceID: "default",
		Trialing:    true,
		ExpiresAt:   expiresAt,
	})
	require.NoError(t, err)
	require.NoError(t, stores.UpdateLicense(ctx, "default", license))
	service.InvalidateCache("default")

	stored, err = service.LoadSubscriptionFromDB(ctx, "default")
	require.NoError(t, err)
	require.Equal(t, v1pb.PlanType_TEAM, stored.Plan)
	require.True(t, stored.Trialing)
	require.Equal(t, expiresAt, stored.ExpiresTime.AsTime())

	effective := service.LoadEffectiveSubscription(ctx, "default")
	require.Equal(t, v1pb.PlanType_FREE, effective.Plan)
	require.Equal(t, expiresAt, effective.ExpiresTime.AsTime())

	require.NoError(t, stores.UpdateLicense(ctx, "default", "not-a-license"))
	service.InvalidateCache("default")
	_, err = service.LoadSubscriptionFromDB(ctx, "default")
	require.Error(t, err)
	require.Equal(t, v1pb.PlanType_FREE, service.LoadEffectiveSubscription(ctx, "default").Plan)
}

func TestGetUserLimitUncached(t *testing.T) {
	ctx := context.Background()
	_, s, _ := testcontainer.NewMetadataDB(t)

	t.Cleanup(func() { s.Close() })

	// Sign licenses with a test-only keypair so finite and expired licenses can
	// be exercised.
	privateKey, err := rsa.GenerateKey(rand.Reader, 2048)
	require.NoError(t, err)
	publicKeyPEM := pem.EncodeToMemory(&pem.Block{Type: "RSA PUBLIC KEY", Bytes: x509.MarshalPKCS1PublicKey(&privateKey.PublicKey)})
	publicKey, err := jwt.ParseRSAPublicKeyFromPEM(publicKeyPEM)
	require.NoError(t, err)
	licenseService := &LicenseService{
		store: s,
		config: &Config{
			PublicKey:  publicKey,
			PrivateKey: privateKey,
			Version:    keyID,
			Issuer:     issuer,
			Audience:   audience,
			Mode:       common.ReleaseModeDev,
		},
		cache: expirable.NewLRU[string, *v1pb.Subscription](8, nil, time.Minute),
	}
	licenseService.replicaCache.Store(&replicaCacheState{replicaCount: 1, loadedAt: time.Now()})

	// No workspace: the Free plan limit applies.
	limit, err := licenseService.GetUserLimitUncached(ctx, "")
	require.NoError(t, err)
	require.Equal(t, userLimitValues[v1pb.PlanType_FREE], limit)

	// Workspace without a license: the Free plan limit applies.
	_, err = s.CreateWorkspace(ctx, &store.WorkspaceMessage{ResourceID: "ws-a"}, "[email protected]")
	require.NoError(t, err)
	limit, err = licenseService.GetUserLimitUncached(ctx, "ws-a")
	require.NoError(t, err)
	require.Equal(t, userLimitValues[v1pb.PlanType_FREE], limit)

	storeLicense := func(t *testing.T, params *LicenseParams) {
		t.Helper()
		token, err := licenseService.CreateLicense(params)
		require.NoError(t, err)
		require.NoError(t, s.UpdateLicense(ctx, "ws-a", token))
	}

	// Finite Enterprise license: the seat claim wins.
	storeLicense(t, &LicenseParams{
		Plan: v1pb.PlanType_ENTERPRISE.String(), Seats: 100, WorkspaceID: "ws-a",
	})
	limit, err = licenseService.GetUserLimitUncached(ctx, "ws-a")
	require.NoError(t, err)
	require.Equal(t, 100, limit)
	state, err := licenseService.GetVerifiedStateUncached(ctx, "ws-a")
	require.NoError(t, err)
	require.Nil(t, state.ExpiresAt)
	require.Equal(t, 100, state.UserLimit)
	require.Equal(t, math.MaxInt, state.InstanceLimit)

	// Legacy Enterprise license without a seat claim: unlimited.
	storeLicense(t, &LicenseParams{
		Plan: v1pb.PlanType_ENTERPRISE.String(), Seats: 0, WorkspaceID: "ws-a",
	})
	limit, err = licenseService.GetUserLimitUncached(ctx, "ws-a")
	require.NoError(t, err)
	require.Equal(t, math.MaxInt, limit)

	// Expired Enterprise license: falls back to the Free plan limit.
	expiresAt := time.Now().Add(-time.Hour)
	storeLicense(t, &LicenseParams{
		Plan: v1pb.PlanType_ENTERPRISE.String(), Seats: 100, WorkspaceID: "ws-a",
		ExpiresAt: expiresAt,
	})
	limit, err = licenseService.GetUserLimitUncached(ctx, "ws-a")
	require.NoError(t, err)
	require.Equal(t, userLimitValues[v1pb.PlanType_FREE], limit)
	state, err = licenseService.GetVerifiedStateUncached(ctx, "ws-a")
	require.NoError(t, err)
	require.WithinDuration(t, expiresAt, *state.ExpiresAt, time.Second)
	require.Equal(t, userLimitValues[v1pb.PlanType_FREE], state.UserLimit)
	require.Equal(t, instanceLimitValues[v1pb.PlanType_FREE], state.InstanceLimit)

	require.NoError(t, s.UpdateLicense(ctx, "ws-a", "not-a-license"))
	_, err = licenseService.GetVerifiedStateUncached(ctx, "ws-a")
	require.Error(t, err)
}