394 lines
13 KiB
Go
394 lines
13 KiB
Go
package controllers
|
|
|
|
import (
|
|
"fmt"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"testing"
|
|
|
|
"GoMembership/internal/constants"
|
|
"GoMembership/internal/database"
|
|
"GoMembership/internal/models"
|
|
"GoMembership/pkg/logger"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
type RegisterSubscriptionTest struct {
|
|
WantDBData map[string]interface{}
|
|
Input string
|
|
Name string
|
|
WantResponse int
|
|
Assert bool
|
|
}
|
|
|
|
type UpdateSubscriptionTest struct {
|
|
WantDBData map[string]interface{}
|
|
Input string
|
|
Name string
|
|
WantResponse int
|
|
Assert bool
|
|
}
|
|
|
|
type DeleteSubscriptionTest struct {
|
|
WantDBData map[string]interface{}
|
|
Input string
|
|
Name string
|
|
WantResponse int
|
|
Assert bool
|
|
}
|
|
|
|
type MockUserController struct {
|
|
UserController // Embed the UserController
|
|
}
|
|
|
|
func (m *MockUserController) ExtractUserFromContext(c *gin.Context) (*models.User, error) {
|
|
return &models.User{
|
|
ID: 1,
|
|
FirstName: "Admin",
|
|
LastName: "User",
|
|
Email: "admin@test.com",
|
|
RoleID: constants.Roles.Admin,
|
|
}, nil
|
|
}
|
|
|
|
func setupMockAuth() {
|
|
// Create and assign the mock controller
|
|
mockController := &MockUserController{}
|
|
Mc.UserController = mockController
|
|
}
|
|
|
|
func testMembershipController(t *testing.T) {
|
|
|
|
setupMockAuth()
|
|
tests := getSubscriptionRegistrationData()
|
|
for _, tt := range tests {
|
|
logger.Error.Print("==============================================================")
|
|
logger.Error.Printf("MembershipController : %v", tt.Name)
|
|
logger.Error.Print("==============================================================")
|
|
t.Run(tt.Name, func(t *testing.T) {
|
|
if err := runSingleTest(&tt); err != nil {
|
|
t.Errorf("Test failed: %v", err.Error())
|
|
}
|
|
})
|
|
}
|
|
updateTests := getSubscriptionUpdateData()
|
|
for _, tt := range updateTests {
|
|
logger.Error.Print("==============================================================")
|
|
logger.Error.Printf("Update SubscriptionData : %v", tt.Name)
|
|
logger.Error.Print("==============================================================")
|
|
t.Run(tt.Name, func(t *testing.T) {
|
|
if err := runSingleTest(&tt); err != nil {
|
|
t.Errorf("Test failed: %v", err.Error())
|
|
}
|
|
})
|
|
}
|
|
deleteTests := getSubscriptionDeleteData()
|
|
for _, tt := range deleteTests {
|
|
logger.Error.Print("==============================================================")
|
|
logger.Error.Printf("Delete SubscriptionData : %v", tt.Name)
|
|
logger.Error.Print("==============================================================")
|
|
t.Run(tt.Name, func(t *testing.T) {
|
|
if err := runSingleTest(&tt); err != nil {
|
|
t.Errorf("Test failed: %v", err.Error())
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func (rt *RegisterSubscriptionTest) SetupContext() (*gin.Context, *httptest.ResponseRecorder, *gin.Engine) {
|
|
return GetMockedJSONContext([]byte(rt.Input), "api/subscription")
|
|
}
|
|
|
|
func (rt *RegisterSubscriptionTest) RunHandler(c *gin.Context, router *gin.Engine) {
|
|
Mc.RegisterSubscription(c)
|
|
}
|
|
|
|
func (rt *RegisterSubscriptionTest) ValidateResponse(w *httptest.ResponseRecorder) error {
|
|
if w.Code != rt.WantResponse {
|
|
return fmt.Errorf("Didn't get the expected response code: got: %v; expected: %v", w.Code, rt.WantResponse)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (rt *RegisterSubscriptionTest) ValidateResult() error {
|
|
return validateSubscription(rt.Assert, rt.WantDBData)
|
|
}
|
|
|
|
func validateSubscription(assert bool, wantDBData map[string]interface{}) error {
|
|
subscriptions, err := Mc.Service.GetSubscriptions(wantDBData)
|
|
if err != nil {
|
|
return fmt.Errorf("Error in database ops: %#v", err)
|
|
}
|
|
if assert != (len(*subscriptions) != 0) {
|
|
return fmt.Errorf("Subscription entry query didn't met expectation: %v != %#v", assert, *subscriptions)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ut *UpdateSubscriptionTest) SetupContext() (*gin.Context, *httptest.ResponseRecorder, *gin.Engine) {
|
|
return GetMockedJSONContext([]byte(ut.Input), "api/subscription/upsert")
|
|
}
|
|
|
|
func (ut *UpdateSubscriptionTest) RunHandler(c *gin.Context, router *gin.Engine) {
|
|
Mc.UpdateHandler(c)
|
|
}
|
|
|
|
func (ut *UpdateSubscriptionTest) ValidateResponse(w *httptest.ResponseRecorder) error {
|
|
if w.Code != ut.WantResponse {
|
|
return fmt.Errorf("Didn't get the expected response code: got: %v; expected: %v", w.Code, ut.WantResponse)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (ut *UpdateSubscriptionTest) ValidateResult() error {
|
|
return validateSubscription(ut.Assert, ut.WantDBData)
|
|
}
|
|
|
|
func (dt *DeleteSubscriptionTest) SetupContext() (*gin.Context, *httptest.ResponseRecorder, *gin.Engine) {
|
|
return GetMockedJSONContext([]byte(dt.Input), "api/subscription/delete")
|
|
}
|
|
|
|
func (dt *DeleteSubscriptionTest) RunHandler(c *gin.Context, router *gin.Engine) {
|
|
Mc.DeleteSubscription(c)
|
|
}
|
|
|
|
func (dt *DeleteSubscriptionTest) ValidateResponse(w *httptest.ResponseRecorder) error {
|
|
if w.Code != dt.WantResponse {
|
|
return fmt.Errorf("Didn't get the expected response code: got: %v; expected: %v", w.Code, dt.WantResponse)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func (dt *DeleteSubscriptionTest) ValidateResult() error {
|
|
return validateSubscription(dt.Assert, dt.WantDBData)
|
|
}
|
|
|
|
func getBaseSubscription() MembershipData {
|
|
return MembershipData{
|
|
// APIKey: config.Auth.APIKEY,
|
|
Subscription: models.SubscriptionModel{
|
|
Name: "Premium",
|
|
Details: "A subscription detail",
|
|
MonthlyFee: 12.0,
|
|
HourlyRate: 14.0,
|
|
},
|
|
}
|
|
}
|
|
func customizeSubscription(customize func(MembershipData) MembershipData) MembershipData {
|
|
subscription := getBaseSubscription()
|
|
return customize(subscription)
|
|
}
|
|
|
|
func getSubscriptionRegistrationData() []RegisterSubscriptionTest {
|
|
return []RegisterSubscriptionTest{
|
|
{
|
|
Name: "Missing details should fail",
|
|
WantResponse: http.StatusBadRequest,
|
|
WantDBData: map[string]interface{}{"name": "Just a Subscription"},
|
|
Assert: false,
|
|
Input: GenerateInputJSON(
|
|
customizeSubscription(func(subscription MembershipData) MembershipData {
|
|
subscription.Subscription.Details = ""
|
|
return subscription
|
|
})),
|
|
},
|
|
{
|
|
Name: "Missing model name should fail",
|
|
WantResponse: http.StatusBadRequest,
|
|
WantDBData: map[string]interface{}{"name": ""},
|
|
Assert: false,
|
|
Input: GenerateInputJSON(
|
|
customizeSubscription(func(subscription MembershipData) MembershipData {
|
|
subscription.Subscription.Name = ""
|
|
return subscription
|
|
})),
|
|
},
|
|
{
|
|
Name: "Negative monthly fee should fail",
|
|
WantResponse: http.StatusBadRequest,
|
|
WantDBData: map[string]interface{}{"name": "Premium"},
|
|
Assert: false,
|
|
Input: GenerateInputJSON(customizeSubscription(func(sub MembershipData) MembershipData {
|
|
sub.Subscription.MonthlyFee = -10.0
|
|
return sub
|
|
})),
|
|
},
|
|
{
|
|
Name: "Negative hourly rate should fail",
|
|
WantResponse: http.StatusBadRequest,
|
|
WantDBData: map[string]interface{}{"name": "Premium"},
|
|
Assert: false,
|
|
Input: GenerateInputJSON(customizeSubscription(func(sub MembershipData) MembershipData {
|
|
sub.Subscription.HourlyRate = -1.0
|
|
return sub
|
|
})),
|
|
},
|
|
{
|
|
Name: "correct entry should pass",
|
|
WantResponse: http.StatusCreated,
|
|
WantDBData: map[string]interface{}{"name": "Premium"},
|
|
Assert: true,
|
|
Input: GenerateInputJSON(
|
|
customizeSubscription(func(subscription MembershipData) MembershipData {
|
|
subscription.Subscription.Conditions = "Some Condition"
|
|
subscription.Subscription.IncludedPerYear = 0
|
|
subscription.Subscription.IncludedPerMonth = 1
|
|
return subscription
|
|
})),
|
|
},
|
|
{
|
|
Name: "Duplicate subscription name should fail",
|
|
WantResponse: http.StatusConflict,
|
|
WantDBData: map[string]interface{}{"name": "Premium"},
|
|
Assert: true, // The original subscription should still exist
|
|
Input: GenerateInputJSON(getBaseSubscription()),
|
|
},
|
|
}
|
|
}
|
|
|
|
func getSubscriptionUpdateData() []UpdateSubscriptionTest {
|
|
return []UpdateSubscriptionTest{
|
|
{
|
|
Name: "Modified Monthly Fee, should fail",
|
|
WantResponse: http.StatusBadRequest,
|
|
WantDBData: map[string]interface{}{"name": "Premium", "monthly_fee": "12"},
|
|
Assert: true,
|
|
Input: GenerateInputJSON(
|
|
customizeSubscription(func(subscription MembershipData) MembershipData {
|
|
subscription.Subscription.MonthlyFee = 123.0
|
|
return subscription
|
|
})),
|
|
},
|
|
{
|
|
Name: "Missing ID, should fail",
|
|
WantResponse: http.StatusBadRequest,
|
|
WantDBData: map[string]interface{}{"name": "Premium"},
|
|
Assert: true,
|
|
Input: GenerateInputJSON(
|
|
customizeSubscription(func(subscription MembershipData) MembershipData {
|
|
subscription.Subscription.ID = 0
|
|
return subscription
|
|
})),
|
|
},
|
|
{
|
|
Name: "Modified Hourly Rate, should fail",
|
|
WantResponse: http.StatusBadRequest,
|
|
WantDBData: map[string]interface{}{"name": "Premium", "hourly_rate": "14"},
|
|
Assert: true,
|
|
Input: GenerateInputJSON(
|
|
customizeSubscription(func(subscription MembershipData) MembershipData {
|
|
subscription.Subscription.HourlyRate = 3254.0
|
|
return subscription
|
|
})),
|
|
},
|
|
{
|
|
Name: "IncludedPerYear changed, should fail",
|
|
WantResponse: http.StatusBadRequest,
|
|
WantDBData: map[string]interface{}{"name": "Premium", "included_per_year": "0"},
|
|
Assert: true,
|
|
Input: GenerateInputJSON(
|
|
customizeSubscription(func(subscription MembershipData) MembershipData {
|
|
subscription.Subscription.IncludedPerYear = 9873.0
|
|
return subscription
|
|
})),
|
|
},
|
|
{
|
|
Name: "IncludedPerMonth changed, should fail",
|
|
WantResponse: http.StatusBadRequest,
|
|
WantDBData: map[string]interface{}{"name": "Premium", "included_per_month": "1"},
|
|
Assert: true,
|
|
Input: GenerateInputJSON(
|
|
customizeSubscription(func(subscription MembershipData) MembershipData {
|
|
subscription.Subscription.IncludedPerMonth = 23415.0
|
|
return subscription
|
|
})),
|
|
},
|
|
{
|
|
Name: "Update non-existent subscription should fail",
|
|
WantResponse: http.StatusNotFound,
|
|
WantDBData: map[string]interface{}{"name": "NonExistentSubscription"},
|
|
Assert: false,
|
|
Input: GenerateInputJSON(
|
|
customizeSubscription(func(subscription MembershipData) MembershipData {
|
|
subscription.Subscription.Name = "NonExistentSubscription"
|
|
return subscription
|
|
})),
|
|
},
|
|
{
|
|
Name: "Correct Update should pass",
|
|
WantResponse: http.StatusAccepted,
|
|
WantDBData: map[string]interface{}{"name": "Premium", "details": "Altered Details"},
|
|
Assert: true,
|
|
Input: GenerateInputJSON(
|
|
customizeSubscription(func(subscription MembershipData) MembershipData {
|
|
subscription.Subscription.Details = "Altered Details"
|
|
subscription.Subscription.Conditions = "Some Condition"
|
|
subscription.Subscription.IncludedPerYear = 0
|
|
subscription.Subscription.IncludedPerMonth = 1
|
|
return subscription
|
|
})),
|
|
},
|
|
}
|
|
}
|
|
|
|
func getSubscriptionDeleteData() []DeleteSubscriptionTest {
|
|
|
|
var premiumSub, basicSub models.SubscriptionModel
|
|
database.DB.Where("name = ?", "Premium").First(&premiumSub)
|
|
database.DB.Where("name = ?", "Basic").First(&basicSub)
|
|
|
|
logger.Error.Printf("premiumSub.ID: %v", premiumSub.ID)
|
|
logger.Error.Printf("basicSub.ID: %v", basicSub.ID)
|
|
return []DeleteSubscriptionTest{
|
|
{
|
|
Name: "Delete non-existent subscription should fail",
|
|
WantResponse: http.StatusNotFound,
|
|
WantDBData: map[string]interface{}{"name": "NonExistentSubscription"},
|
|
Assert: false,
|
|
Input: GenerateInputJSON(
|
|
customizeSubscription(func(subscription MembershipData) MembershipData {
|
|
subscription.Subscription.Name = "NonExistentSubscription"
|
|
subscription.Subscription.ID = basicSub.ID
|
|
return subscription
|
|
})),
|
|
},
|
|
{
|
|
Name: "Delete subscription without name should fail",
|
|
WantResponse: http.StatusExpectationFailed,
|
|
WantDBData: map[string]interface{}{"name": ""},
|
|
Assert: false,
|
|
Input: GenerateInputJSON(
|
|
customizeSubscription(func(subscription MembershipData) MembershipData {
|
|
subscription.Subscription.Name = ""
|
|
subscription.Subscription.ID = basicSub.ID
|
|
return subscription
|
|
})),
|
|
},
|
|
{
|
|
Name: "Delete subscription with users should fail",
|
|
WantResponse: http.StatusExpectationFailed,
|
|
WantDBData: map[string]interface{}{"name": "Basic"},
|
|
Assert: true,
|
|
Input: GenerateInputJSON(
|
|
customizeSubscription(func(subscription MembershipData) MembershipData {
|
|
subscription.Subscription.Name = "Basic"
|
|
subscription.Subscription.ID = basicSub.ID
|
|
return subscription
|
|
})),
|
|
},
|
|
{
|
|
Name: "Delete valid subscription should succeed",
|
|
WantResponse: http.StatusOK,
|
|
WantDBData: map[string]interface{}{"name": "Premium"},
|
|
Assert: false,
|
|
Input: GenerateInputJSON(
|
|
customizeSubscription(func(subscription MembershipData) MembershipData {
|
|
subscription.Subscription.Name = "Premium"
|
|
subscription.Subscription.ID = premiumSub.ID
|
|
return subscription
|
|
})),
|
|
},
|
|
}
|
|
}
|