chore: additional tests

deansheather · deansheather · commit 777bcf2b78c8 · 2025-07-15T10:55:24.000Z
diff --git a/enterprise/coderd/coderdenttest/coderdenttest.go b/enterprise/coderd/coderdenttest/coderdenttest.go
@@ -183,6 +183,11 @@ type LicenseOptions struct {
 	Features license.Features
 }
 
+func (opts *LicenseOptions) WithIssuedAt(now time.Time) *LicenseOptions {
+	opts.IssuedAt = now
+	return opts
+}
+
 func (opts *LicenseOptions) Expired(now time.Time) *LicenseOptions {
 	opts.NotBefore = now.Add(time.Hour * 24 * -4) // needs to be before the grace period
 	opts.ExpiresAt = now.Add(time.Hour * 24 * -2)
@@ -214,6 +219,14 @@ func (opts *LicenseOptions) UserLimit(limit int64) *LicenseOptions {
 	return opts.Feature(codersdk.FeatureUserLimit, limit)
 }
 
+func (opts *LicenseOptions) ManagedAgentLimit(soft int64, hard int64) *LicenseOptions {
+	// These don't use named or exported feature names, see
+	// enterprise/coderd/license/license.go.
+	opts = opts.Feature(codersdk.FeatureName("managed_agent_limit_soft"), soft)
+	opts = opts.Feature(codersdk.FeatureName("managed_agent_limit_hard"), hard)
+	return opts
+}
+
 func (opts *LicenseOptions) Feature(name codersdk.FeatureName, value int64) *LicenseOptions {
 	if opts.Features == nil {
 		opts.Features = license.Features{}
diff --git a/enterprise/coderd/license/license.go b/enterprise/coderd/license/license.go
@@ -439,10 +439,10 @@ func LicensesEntitlements(
 			if hardLimit > softLimit && softLimit > 0 {
 				softWarningThreshold = softLimit + int64(float64(hardLimit-softLimit)*0.75)
 			}
-			if managedAgentCount > *agentLimit.Limit {
+			if managedAgentCount >= *agentLimit.Limit {
 				entitlements.Warnings = append(entitlements.Warnings,
 					"You have built more workspaces with managed agents than your license allows. Further managed agent builds will be blocked.")
-			} else if managedAgentCount > softWarningThreshold {
+			} else if managedAgentCount >= softWarningThreshold {
 				entitlements.Warnings = append(entitlements.Warnings,
 					"You are approaching the managed agent limit in your license. Please refer to the Deployment Licenses page for more information.")
 			}
diff --git a/enterprise/coderd/license/license_test.go b/enterprise/coderd/license/license_test.go
@@ -888,6 +888,164 @@ func TestLicenseEntitlements(t *testing.T) {
 					entitlements.Features[codersdk.FeatureCustomRoles].Entitlement)
 			},
 		},
+		{
+			Name: "ManagedAgentLimit",
+			Licenses: []*coderdenttest.LicenseOptions{
+				enterpriseLicense().UserLimit(100).ManagedAgentLimit(100, 200),
+			},
+			Arguments: license.FeatureArguments{
+				ManagedAgentCountFn: func(ctx context.Context, from time.Time, to time.Time) (int64, error) {
+					// 175 will generate a warning as it's over 75% of the
+					// difference between the soft and hard limit.
+					return 174, nil
+				},
+			},
+			AssertEntitlements: func(t *testing.T, entitlements codersdk.Entitlements) {
+				assertNoErrors(t, entitlements)
+				assertNoWarnings(t, entitlements)
+				feature := entitlements.Features[codersdk.FeatureManagedAgentLimit]
+				assert.Equal(t, codersdk.EntitlementEntitled, feature.Entitlement)
+				assert.True(t, feature.Enabled)
+				assert.Equal(t, int64(100), *feature.SoftLimit)
+				assert.Equal(t, int64(200), *feature.Limit)
+				assert.Equal(t, int64(174), *feature.Actual)
+			},
+		},
+		{
+			Name: "ManagedAgentLimitWithGrace",
+			Licenses: []*coderdenttest.LicenseOptions{
+				// Add another license that is not entitled to managed agents to
+				// suppress warnings for other features.
+				enterpriseLicense().
+					UserLimit(100).
+					WithIssuedAt(time.Now().Add(-time.Hour * 2)),
+				enterpriseLicense().
+					UserLimit(100).
+					ManagedAgentLimit(100, 100).
+					WithIssuedAt(time.Now().Add(-time.Hour * 1)).
+					GracePeriod(time.Now()),
+			},
+			Arguments: license.FeatureArguments{
+				ManagedAgentCountFn: func(ctx context.Context, from time.Time, to time.Time) (int64, error) {
+					// When the soft and hard limit are equal, the warning is
+					// triggered at 75% of the hard limit.
+					return 74, nil
+				},
+			},
+			AssertEntitlements: func(t *testing.T, entitlements codersdk.Entitlements) {
+				assertNoErrors(t, entitlements)
+				assertNoWarnings(t, entitlements)
+				feature := entitlements.Features[codersdk.FeatureManagedAgentLimit]
+				assert.Equal(t, codersdk.EntitlementGracePeriod, feature.Entitlement)
+				assert.True(t, feature.Enabled)
+				assert.Equal(t, int64(100), *feature.SoftLimit)
+				assert.Equal(t, int64(100), *feature.Limit)
+				assert.Equal(t, int64(74), *feature.Actual)
+			},
+		},
+		{
+			Name: "ManagedAgentLimitWithExpired",
+			Licenses: []*coderdenttest.LicenseOptions{
+				// Add another license that is not entitled to managed agents to
+				// suppress warnings for other features.
+				enterpriseLicense().
+					UserLimit(100).
+					WithIssuedAt(time.Now().Add(-time.Hour * 2)),
+				enterpriseLicense().
+					UserLimit(100).
+					ManagedAgentLimit(100, 200).
+					WithIssuedAt(time.Now().Add(-time.Hour * 1)).
+					Expired(time.Now()),
+			},
+			Arguments: license.FeatureArguments{
+				ManagedAgentCountFn: func(ctx context.Context, from time.Time, to time.Time) (int64, error) {
+					return 10, nil
+				},
+			},
+			AssertEntitlements: func(t *testing.T, entitlements codersdk.Entitlements) {
+				feature := entitlements.Features[codersdk.FeatureManagedAgentLimit]
+				assert.Equal(t, codersdk.EntitlementNotEntitled, feature.Entitlement)
+				assert.False(t, feature.Enabled)
+				assert.Nil(t, feature.SoftLimit)
+				assert.Nil(t, feature.Limit)
+				assert.Nil(t, feature.Actual)
+			},
+		},
+		{
+			Name: "ManagedAgentLimitWarning/ApproachingLimit/DifferentSoftAndHardLimit",
+			Licenses: []*coderdenttest.LicenseOptions{
+				enterpriseLicense().
+					UserLimit(100).
+					ManagedAgentLimit(100, 200),
+			},
+			Arguments: license.FeatureArguments{
+				ManagedAgentCountFn: func(ctx context.Context, from time.Time, to time.Time) (int64, error) {
+					return 175, nil
+				},
+			},
+			AssertEntitlements: func(t *testing.T, entitlements codersdk.Entitlements) {
+				assert.Len(t, entitlements.Warnings, 1)
+				assert.Equal(t, "You are approaching the managed agent limit in your license. Please refer to the Deployment Licenses page for more information.", entitlements.Warnings[0])
+				assertNoErrors(t, entitlements)
+
+				feature := entitlements.Features[codersdk.FeatureManagedAgentLimit]
+				assert.Equal(t, codersdk.EntitlementEntitled, feature.Entitlement)
+				assert.True(t, feature.Enabled)
+				assert.Equal(t, int64(100), *feature.SoftLimit)
+				assert.Equal(t, int64(200), *feature.Limit)
+				assert.Equal(t, int64(175), *feature.Actual)
+			},
+		},
+		{
+			Name: "ManagedAgentLimitWarning/ApproachingLimit/EqualSoftAndHardLimit",
+			Licenses: []*coderdenttest.LicenseOptions{
+				enterpriseLicense().
+					UserLimit(100).
+					ManagedAgentLimit(100, 100),
+			},
+			Arguments: license.FeatureArguments{
+				ManagedAgentCountFn: func(ctx context.Context, from time.Time, to time.Time) (int64, error) {
+					return 75, nil
+				},
+			},
+			AssertEntitlements: func(t *testing.T, entitlements codersdk.Entitlements) {
+				assert.Len(t, entitlements.Warnings, 1)
+				assert.Equal(t, "You are approaching the managed agent limit in your license. Please refer to the Deployment Licenses page for more information.", entitlements.Warnings[0])
+				assertNoErrors(t, entitlements)
+
+				feature := entitlements.Features[codersdk.FeatureManagedAgentLimit]
+				assert.Equal(t, codersdk.EntitlementEntitled, feature.Entitlement)
+				assert.True(t, feature.Enabled)
+				assert.Equal(t, int64(100), *feature.SoftLimit)
+				assert.Equal(t, int64(100), *feature.Limit)
+				assert.Equal(t, int64(75), *feature.Actual)
+			},
+		},
+		{
+			Name: "ManagedAgentLimitWarning/BreachedLimit",
+			Licenses: []*coderdenttest.LicenseOptions{
+				enterpriseLicense().
+					UserLimit(100).
+					ManagedAgentLimit(100, 200),
+			},
+			Arguments: license.FeatureArguments{
+				ManagedAgentCountFn: func(ctx context.Context, from time.Time, to time.Time) (int64, error) {
+					return 200, nil
+				},
+			},
+			AssertEntitlements: func(t *testing.T, entitlements codersdk.Entitlements) {
+				assert.Len(t, entitlements.Warnings, 1)
+				assert.Equal(t, "You have built more workspaces with managed agents than your license allows. Further managed agent builds will be blocked.", entitlements.Warnings[0])
+				assertNoErrors(t, entitlements)
+
+				feature := entitlements.Features[codersdk.FeatureManagedAgentLimit]
+				assert.Equal(t, codersdk.EntitlementEntitled, feature.Entitlement)
+				assert.True(t, feature.Enabled)
+				assert.Equal(t, int64(100), *feature.SoftLimit)
+				assert.Equal(t, int64(200), *feature.Limit)
+				assert.Equal(t, int64(200), *feature.Actual)
+			},
+		},
 	}
 
 	for _, tc := range testCases {

Original file line number	Diff line number	Diff line change
`@@ -439,10 +439,10 @@ func LicensesEntitlements(`
`439`	`439`	`if hardLimit > softLimit && softLimit > 0 {`
`440`	`440`	`softWarningThreshold = softLimit + int64(float64(hardLimit-softLimit)*0.75)`
`441`	`441`	`}`
`442`		`- if managedAgentCount > *agentLimit.Limit {`
	`442`	`+ if managedAgentCount >= *agentLimit.Limit {`
`443`	`443`	`entitlements.Warnings = append(entitlements.Warnings,`
`444`	`444`	`"You have built more workspaces with managed agents than your license allows. Further managed agent builds will be blocked.")`
`445`		`- } else if managedAgentCount > softWarningThreshold {`
	`445`	`+ } else if managedAgentCount >= softWarningThreshold {`
`446`	`446`	`entitlements.Warnings = append(entitlements.Warnings,`
`447`	`447`	`"You are approaching the managed agent limit in your license. Please refer to the Deployment Licenses page for more information.")`
`448`	`448`	`}`