Merge pull request #37 from SanctumLabs/develop

No redirects for Expired URLs

Author: BrianLusina

.env.sample

@@ -16,7 +16,7 @@ DATABASE_PASSWORD=curtzPassword
 DATABASE_PORT=27017
 DATABASE_USES_SRV=true
 CACHE_HOST=localhost
-CACHE_PORT=6370
+CACHE_PORT=6379
 CACHE_USERNAME=curtzUser
 CACHE_PASSWORD=curtzPassword
 CACHE_REQUIRE_AUTH=false

app/api/v1/url/handlers.go

@@ -117,7 +117,7 @@ func (hdl *urlRouter) updateUrl(c *gin.Context) {
 	keywords := payload.Keywords
 	expiresOn := payload.ExpiresOn
 
-	updateCmd, err := contracts.NewUpdateUrlCommand(userId.(string), urlId, customAlias, keywords, expiresOn)
+	updateCmd, err := contracts.NewUpdateUrlRequest(userId.(string), urlId, customAlias, keywords, expiresOn)
 	if err != nil {
 		c.AbortWithStatusJSON(http.StatusBadRequest, map[string]any{"message": err.Error()})
 		return

app/cmd/main.go

@@ -11,6 +11,8 @@ import (
 	"github.com/sanctumlabs/curtz/app/api/v1/url"
 	"github.com/sanctumlabs/curtz/app/config"
 	"github.com/sanctumlabs/curtz/app/internal/core/urlsvc"
+	urlReadSvc "github.com/sanctumlabs/curtz/app/internal/core/urlsvc/read"
+	urlWriteSvc "github.com/sanctumlabs/curtz/app/internal/core/urlsvc/write"
 	"github.com/sanctumlabs/curtz/app/internal/core/usersvc"
 	"github.com/sanctumlabs/curtz/app/internal/repositories"
 	"github.com/sanctumlabs/curtz/app/internal/services/auth"
@@ -187,8 +189,8 @@ func main() {
 
 	userService := usersvc.NewUserSvc(repository.GetUserRepo(), notificationSvc)
 	urlService := urlsvc.NewUrlSvc(repository.GetUrlReadRepo(), repository.GetUrlWriteRepo(), userService, cache)
-	urlReadService := urlsvc.NewUrlReadSvc(repository.GetUrlReadRepo(), userService, cache)
-	urlWriteService := urlsvc.NewUrlWriteSvc(repository.GetUrlWriteRepo(), userService)
+	urlReadService := urlReadSvc.NewUrlReadSvc(repository.GetUrlReadRepo(), userService, cache)
+	urlWriteService := urlWriteSvc.NewUrlWriteSvc(repository.GetUrlWriteRepo(), userService)
 
 	baseUri := "/api/v1/curtz"
 

app/internal/core/contracts/commands.go

@@ -6,44 +6,36 @@ import (
 	"github.com/sanctumlabs/curtz/app/pkg/validators"
 )
 
-type CreateUrlCommand struct {
-	userID      string
-	originalUrl string
-	customAlias string
-	expiresOn   time.Time
-	keywords    []string
-}
-
-type UpdateUrlCommand struct {
+type UpdateUrlRequest struct {
 	UserId      string
 	UrlId       string
 	CustomAlias string
 	Keywords    []string
 	ExpiresOn   *time.Time
 }
 
-func NewUpdateUrlCommand(userId, urlId, customAlias string, keywords []string, expiresOn *time.Time) (UpdateUrlCommand, error) {
+func NewUpdateUrlRequest(userId, urlId, customAlias string, keywords []string, expiresOn *time.Time) (UpdateUrlRequest, error) {
 	if err := validators.IsValidUserId(userId); err != nil {
-		return UpdateUrlCommand{}, err
+		return UpdateUrlRequest{}, err
 	}
 
 	if err := validators.IsValidUrlId(urlId); err != nil {
-		return UpdateUrlCommand{}, err
+		return UpdateUrlRequest{}, err
 	}
 
 	if len(customAlias) != 0 {
 		if err := validators.IsValidCustomAlias(customAlias); err != nil {
-			return UpdateUrlCommand{}, err
+			return UpdateUrlRequest{}, err
 		}
 	}
 
 	if expiresOn != nil {
 		if err := validators.IsValidExpirationTime(*expiresOn); err != nil {
-			return UpdateUrlCommand{}, err
+			return UpdateUrlRequest{}, err
 		}
 	}
 
-	return UpdateUrlCommand{
+	return UpdateUrlRequest{
 		UserId:      userId,
 		UrlId:       urlId,
 		CustomAlias: customAlias,

app/internal/core/contracts/services.go

@@ -29,5 +29,5 @@ type SmsService interface {
 // CacheService interface to be used by services that implement cache like functionality
 type CacheService interface {
 	LookupUrl(shortCode string) (string, error)
-	SaveUrl(shortCode, originalUrl string) (string, error)
+	SaveURL(shortCode, originalUrl string, expiryTime time.Duration) (string, error)
 }

app/internal/core/contracts/update_url_command_test.go

@@ -57,12 +57,12 @@ var testCases = []testCase{
 	},
 }
 
-func TestNewUpdateUrlCommand(t *testing.T) {
+func TestNewUpdateUrlRequest(t *testing.T) {
 	for _, tc := range testCases {
 		t.Run(tc.name, func(t *testing.T) {
-			actual, err := NewUpdateUrlCommand(tc.userId, tc.urlId, tc.customAlias, tc.keywords, &tc.expiresOn)
+			actual, err := NewUpdateUrlRequest(tc.userId, tc.urlId, tc.customAlias, tc.keywords, &tc.expiresOn)
 			if err != tc.expectedErr {
-				t.Errorf("NewUpdateUrlCommand(%s, %s, %s, %s, %v) = %v expected error %v, got %v", tc.userId, tc.urlId, tc.customAlias, tc.keywords, tc.expiresOn, tc.expectedErr, tc.expectedErr, err)
+				t.Errorf("NewUpdateUrlRequest(%s, %s, %s, %s, %v) = %v expected error %v, got %v", tc.userId, tc.urlId, tc.customAlias, tc.keywords, tc.expiresOn, tc.expectedErr, tc.expectedErr, err)
 			} else if tc.expectedErr == nil {
 				assert.Equal(t, tc.userId, actual.UserId)
 				assert.Equal(t, tc.urlId, actual.UrlId)
@@ -74,14 +74,14 @@ func TestNewUpdateUrlCommand(t *testing.T) {
 	}
 }
 
-func BenchmarkNewUpdateUrlCommand(b *testing.B) {
+func BenchmarkNewUpdateUrlRequest(b *testing.B) {
 	if testing.Short() {
 		b.Skip("skipping benchmark")
 	}
 
 	for i := 0; i < b.N; i++ {
 		for _, tc := range testCases {
-			_, _ = NewUpdateUrlCommand(tc.userId, tc.urlId, tc.customAlias, tc.keywords, &tc.expiresOn)
+			_, _ = NewUpdateUrlRequest(tc.userId, tc.urlId, tc.customAlias, tc.keywords, &tc.expiresOn)
 		}
 	}
 }

app/internal/core/contracts/url_service.go

@@ -24,6 +24,6 @@ type UrlReadService interface {
 // UrlWriteService performs write operations on URLs
 type UrlWriteService interface {
 	CreateUrl(userID string, originalUrl string, customAlias string, expiresOn time.Time, keywords []string) (entities.URL, error)
-	UpdateUrl(url UpdateUrlCommand) (entities.URL, error)
+	UpdateUrl(url UpdateUrlRequest) (entities.URL, error)
 	Remove(id string) error
 }

app/internal/core/entities/url.go

@@ -109,8 +109,7 @@ func NewUrl(userId identifier.ID, originalUrl string, customAlias string, expire
 	}, nil
 }
 
-// IsActive checks if the url model is active
-// It returns true if url is not marked deleted or expired, false otherwise.
+// IsActive checks if the url is active or not expired.
 func (url URL) IsActive() bool {
 	return url.ExpiresOn.In(time.UTC).After(time.Now().In(time.UTC))
 }
@@ -152,6 +151,16 @@ func (url URL) SetCustomAlias(customAlias string) error {
 	return nil
 }
 
+// GetExpiryDuration returns as a time.Duration how long before the url expires
+// This returns an absolute value after subtracting time.Now()
+func (url URL) GetExpiryDuration() time.Duration {
+	duration := time.Until(url.ExpiresOn)
+	if duration >= 0 {
+		return duration
+	}
+	return -duration
+}
+
 // Prefix returns the url prefix for logging
 func (url URL) Prefix() string {
 	return fmt.Sprintf("url-%s-%s", url.ID, url.ShortCode)

app/internal/core/entities/url_test.go

@@ -4,6 +4,7 @@ import (
 	"testing"
 	"time"
 
+	"bou.ke/monkey"
 	"github.com/sanctumlabs/curtz/app/pkg/errdefs"
 	"github.com/sanctumlabs/curtz/app/pkg/identifier"
 )
@@ -99,3 +100,42 @@ func BenchmarkNewUrl(b *testing.B) {
 		})
 	}
 }
+
+type urlExpiryTestCase struct {
+	urlTestCase
+	duration time.Duration
+}
+
+func TestGetExpiryDuration(t *testing.T) {
+	monkey.Patch(time.Now, func() time.Time {
+		return time.Date(2022, 9, 19, 16, 20, 00, 651387237, time.UTC)
+	})
+
+	urlExpiryTestCases := []urlExpiryTestCase{
+		{
+			urlTestCase: urlTestCase{
+				name:          "should return duration expiry for given URL",
+				userId:        identifier.New(),
+				url:           "http://example.com",
+				alias:         "",
+				expiresOn:     time.Now().Add(time.Hour * 1),
+				keywords:      []string{},
+				expectedError: nil,
+			},
+			duration: time.Until(time.Now().Add(time.Hour * 1)),
+		},
+	}
+
+	for _, tc := range urlExpiryTestCases {
+		t.Run(tc.name, func(t *testing.T) {
+			url, err := NewUrl(tc.userId, tc.url, tc.alias, tc.expiresOn, tc.keywords)
+			if err != tc.expectedError {
+				t.Errorf("NewUrl(%v, %s, %s, %s, %v) = (%v, %v) expected error: %v, got: %v", tc.userId, tc.url, tc.alias, tc.expiresOn, tc.keywords, url, err, tc.expectedError, err)
+			}
+			actualExpiry := url.GetExpiryDuration()
+			if tc.duration != actualExpiry {
+				t.Errorf("url.GetExpiryDuration() = %d expected = %d", actualExpiry, tc.duration)
+			}
+		})
+	}
+}

app/internal/core/urlsvc/url_readsvc.go renamed to app/internal/core/urlsvc/read/url_readsvc.go

@@ -1,4 +1,4 @@
-package urlsvc
+package read
 
 import (
 	"github.com/sanctumlabs/curtz/app/internal/core/contracts"