Add limit count of deployment.

Author: noah

internal/interactor/interface.go

@@ -45,6 +45,7 @@ type (
 		UpdatePerm(ctx context.Context, p *ent.Perm) (*ent.Perm, error)
 		DeletePermsOfUserLessThanSyncedAt(ctx context.Context, u *ent.User, t time.Time) (int, error)
 
+		CountDeployments(ctx context.Context) (int, error)
 		SearchDeployments(ctx context.Context, u *ent.User, s []deployment.Status, owned bool, from time.Time, to time.Time, page, perPage int) ([]*ent.Deployment, error)
 		ListInactiveDeploymentsLessThanTime(ctx context.Context, t time.Time, page, perPage int) ([]*ent.Deployment, error)
 		ListDeploymentsOfRepo(ctx context.Context, r *ent.Repo, env string, status string, page, perPage int) ([]*ent.Deployment, error)

internal/interactor/license.go

@@ -15,24 +15,29 @@ import (
 
 func (i *Interactor) GetLicense(ctx context.Context) (*vo.License, error) {
 	var (
-		cnt int
-		d   *vo.SigningData
-		err error
+		memberCnt     int
+		deploymentCnt int
+		d             *vo.SigningData
+		err           error
 	)
 
-	if cnt, err = i.Store.CountUsers(ctx); err != nil {
+	if memberCnt, err = i.Store.CountUsers(ctx); err != nil {
+		return nil, err
+	}
+
+	if deploymentCnt, err = i.Store.CountDeployments(ctx); err != nil {
 		return nil, err
 	}
 
 	if i.licenseKey == "" {
-		lic := vo.NewTrialLicense(cnt)
+		lic := vo.NewTrialLicense(memberCnt, deploymentCnt)
 		return lic, nil
 	}
 
 	if d, err = license.Decode(i.licenseKey); err != nil {
 		return nil, err
 	}
 
-	lic := vo.NewStandardLicense(cnt, d)
+	lic := vo.NewStandardLicense(memberCnt, d)
 	return lic, nil
 }

internal/interactor/license_test.go

@@ -18,7 +18,12 @@ func TestStore_GetLicense(t *testing.T) {
 		store.
 			EXPECT().
 			CountUsers(gomock.AssignableToTypeOf(context.Background())).
-			Return(5, nil)
+			Return(vo.TrialMemberLimit, nil)
+
+		store.
+			EXPECT().
+			CountDeployments(gomock.AssignableToTypeOf(context.Background())).
+			Return(vo.TrialDeploymentLimit, nil)
 
 		i := &Interactor{Store: store}
 

internal/interactor/mock/pkg.go

@@ -11,6 +11,12 @@ import (
 	"github.com/gitploy-io/gitploy/ent/predicate"
 )
 
+func (s *Store) CountDeployments(ctx context.Context) (int, error) {
+	return s.c.Deployment.
+		Query().
+		Count(ctx)
+}
+
 func (s *Store) SearchDeployments(ctx context.Context, u *ent.User, ss []deployment.Status, owned bool, from time.Time, to time.Time, page, perPage int) ([]*ent.Deployment, error) {
 	statusIn := func(ss []deployment.Status) predicate.Deployment {
 		if len(ss) == 0 {

internal/pkg/store/deployment.go

@@ -49,7 +49,7 @@ func TestMiddleware_IsLicenseExpired(t *testing.T) {
 		m.
 			EXPECT().
 			GetLicense(gomock.Any()).
-			Return(vo.NewTrialLicense(7), nil)
+			Return(vo.NewTrialLicense(vo.TrialMemberLimit+1, vo.TrialDeploymentLimit), nil)
 
 		gin.SetMode(gin.ReleaseMode)
 		router := gin.New()
@@ -76,7 +76,7 @@ func TestMiddleware_IsLicenseExpired(t *testing.T) {
 		m.
 			EXPECT().
 			GetLicense(gomock.Any()).
-			Return(vo.NewTrialLicense(vo.TrialMemberLimit), nil)
+			Return(vo.NewTrialLicense(vo.TrialMemberLimit, vo.TrialDeploymentLimit), nil)
 
 		gin.SetMode(gin.ReleaseMode)
 		router := gin.New()

internal/server/api/shared/middleware_test.go

@@ -3,7 +3,8 @@ package vo
 import "time"
 
 const (
-	TrialMemberLimit = 5
+	TrialMemberLimit     = 5
+	TrialDeploymentLimit = 5000
 )
 
 const (
@@ -19,10 +20,12 @@ type (
 	LicenseKind string
 
 	License struct {
-		Kind        LicenseKind `json:"kind"`
-		MemberCount int         `json:"member_count"`
-		MemberLimit int         `json:"memeber_limit"`
-		ExpiredAt   time.Time   `json:"expired_at"`
+		Kind            LicenseKind `json:"kind"`
+		MemberCount     int         `json:"member_count"`
+		MemberLimit     int         `json:"memeber_limit"`
+		DeploymentCount int         `json:"deployment_count"`
+		DeploymentLimit int         `json:"deployment_limit"`
+		ExpiredAt       time.Time   `json:"expired_at"`
 	}
 
 	// SigningData marshal and unmarshal the content of license.
@@ -34,25 +37,29 @@ type (
 
 func NewOSSLicense() *License {
 	return &License{
-		Kind:        LicenseKindOSS,
-		MemberCount: -1,
+		Kind:            LicenseKindOSS,
+		MemberCount:     -1,
+		DeploymentCount: -1,
 	}
 }
 
-func NewTrialLicense(cnt int) *License {
+func NewTrialLicense(memberCnt, deploymentCnt int) *License {
 	return &License{
-		Kind:        LicenseKindTrial,
-		MemberCount: cnt,
-		MemberLimit: TrialMemberLimit,
+		Kind:            LicenseKindTrial,
+		MemberCount:     memberCnt,
+		MemberLimit:     TrialMemberLimit,
+		DeploymentCount: deploymentCnt,
+		DeploymentLimit: TrialDeploymentLimit,
 	}
 }
 
-func NewStandardLicense(cnt int, d *SigningData) *License {
+func NewStandardLicense(memberCnt int, d *SigningData) *License {
 	return &License{
-		Kind:        LicenseKindStandard,
-		MemberCount: cnt,
-		MemberLimit: d.MemberLimit,
-		ExpiredAt:   d.ExpiredAt,
+		Kind:            LicenseKindStandard,
+		MemberCount:     memberCnt,
+		MemberLimit:     d.MemberLimit,
+		DeploymentCount: -1,
+		ExpiredAt:       d.ExpiredAt,
 	}
 }
 
@@ -70,7 +77,7 @@ func (l *License) IsStandard() bool {
 
 // IsOverLimit verify it is over the limit of the license.
 func (l *License) IsOverLimit() bool {
-	return l.MemberCount > l.MemberLimit
+	return l.MemberCount > l.MemberLimit || l.DeploymentCount > l.DeploymentLimit
 }
 
 // IsExpired verify that the license is expired or not.

vo/license.go

@@ -6,23 +6,44 @@ import (
 )
 
 func TestLicense_IsOverLimit(t *testing.T) {
-	t.Run("Return false when the count of member is over the limit.", func(t *testing.T) {
-		l := NewTrialLicense(6)
+	t.Run("Return false when the license is OSS.", func(t *testing.T) {
+		l := NewOSSLicense()
+
+		expected := false
+		if finished := l.IsOverLimit(); finished != expected {
+			t.Fatalf("IsOverLimit = %v, wanted %v", finished, expected)
+		}
+	})
+
+	t.Run("Return true when the trial license is over the member limit.", func(t *testing.T) {
+		l := NewTrialLicense(TrialMemberLimit+1, 0)
 
 		expected := true
 		if finished := l.IsOverLimit(); finished != expected {
 			t.Fatalf("IsOverLimit = %v, wanted %v", finished, expected)
 		}
 	})
 
-	t.Run("Return true when the count of member is under the limit.", func(t *testing.T) {
-		tl := NewTrialLicense(5)
+	t.Run("Return true when the trial license is over the deployment limit.", func(t *testing.T) {
+		l := NewTrialLicense(5, TrialDeploymentLimit+1)
 
-		if finished := tl.IsOverLimit(); finished != false {
-			t.Fatalf("IsOverLimit = %v, wanted %v", finished, false)
+		expected := true
+		if finished := l.IsOverLimit(); finished != expected {
+			t.Fatalf("IsOverLimit = %v, wanted %v", finished, expected)
 		}
+	})
+
+	t.Run("Return false when the trial license is less than or equal to the limit.", func(t *testing.T) {
+		l := NewTrialLicense(TrialMemberLimit, TrialDeploymentLimit)
+
+		expected := false
+		if finished := l.IsOverLimit(); finished != expected {
+			t.Fatalf("IsOverLimit = %v, wanted %v", finished, expected)
+		}
+	})
 
-		sl := NewStandardLicense(10, &SigningData{
+	t.Run("Return true when the standard license is less than the limit.", func(t *testing.T) {
+		sl := NewStandardLicense(20, &SigningData{
 			MemberLimit: 20,
 			ExpiredAt:   time.Now(),
 		})