flamingo.me/flamingo-commerce/v3@v3.11.0/checkout/domain/placeorder/states/validate_cart_test.go (about)

     1  package states_test
     2  
     3  import (
     4  	"context"
     5  	"testing"
     6  
     7  	"flamingo.me/flamingo/v3/framework/flamingo"
     8  	"flamingo.me/flamingo/v3/framework/web"
     9  	"github.com/go-test/deep"
    10  	"github.com/stretchr/testify/assert"
    11  	"github.com/stretchr/testify/mock"
    12  
    13  	"flamingo.me/flamingo-commerce/v3/cart/application"
    14  	cartDomain "flamingo.me/flamingo-commerce/v3/cart/domain/cart"
    15  	"flamingo.me/flamingo-commerce/v3/cart/domain/cart/mocks"
    16  	"flamingo.me/flamingo-commerce/v3/cart/domain/decorator"
    17  	"flamingo.me/flamingo-commerce/v3/cart/domain/placeorder"
    18  	"flamingo.me/flamingo-commerce/v3/cart/domain/validation"
    19  	"flamingo.me/flamingo-commerce/v3/checkout/domain/placeorder/process"
    20  	"flamingo.me/flamingo-commerce/v3/checkout/domain/placeorder/states"
    21  	"flamingo.me/flamingo-commerce/v3/price/domain"
    22  )
    23  
    24  type (
    25  	validator struct {
    26  		Valid bool
    27  	}
    28  )
    29  
    30  func (v *validator) Validate(_ context.Context, _ *web.Session, _ *decorator.DecoratedCart) validation.Result {
    31  	return validation.Result{HasCommonError: !v.Valid}
    32  }
    33  
    34  func TestValidateCart_Name(t *testing.T) {
    35  	s := states.ValidateCart{}
    36  	assert.Equal(t, "ValidateCart", s.Name())
    37  }
    38  
    39  func TestValidateCart_Rollback(t *testing.T) {
    40  	s := states.ValidateCart{}
    41  	assert.Nil(t, s.Rollback(context.Background(), nil))
    42  }
    43  
    44  func TestValidateCart_Run(t *testing.T) {
    45  	tests := []struct {
    46  		name             string
    47  		isValid          bool
    48  		isGrandTotalZero bool
    49  		expectedState    string
    50  		expectedResult   process.RunResult
    51  	}{
    52  		{
    53  			name:             "Valid cart that requires payment",
    54  			isValid:          true,
    55  			isGrandTotalZero: false,
    56  			expectedState:    states.ValidatePaymentSelection{}.Name(),
    57  			expectedResult:   process.RunResult{},
    58  		},
    59  		{
    60  			name:             "Valid cart that is fully discounted, no payment needed",
    61  			isValid:          true,
    62  			isGrandTotalZero: true,
    63  			expectedState:    states.CompleteCart{}.Name(),
    64  			expectedResult:   process.RunResult{},
    65  		},
    66  		{
    67  			name:             "Invalid",
    68  			isValid:          false,
    69  			isGrandTotalZero: false,
    70  			expectedState:    states.ValidateCart{}.Name(),
    71  			expectedResult: process.RunResult{
    72  				RollbackData: nil,
    73  				Failed: process.CartValidationErrorReason{
    74  					ValidationResult: validation.Result{
    75  						HasCommonError: true,
    76  					},
    77  				},
    78  			},
    79  		},
    80  	}
    81  
    82  	// global service setup
    83  	cartReceiverService := &application.CartReceiverService{}
    84  	guestCartService := new(mocks.GuestCartService)
    85  	guestCartService.EXPECT().GetNewCart(mock.Anything).Return(&cartDomain.Cart{ID: "mock_guest_cart"}, nil)
    86  	cartReceiverService.Inject(
    87  		guestCartService,
    88  		new(mocks.CustomerCartService),
    89  		func() *decorator.DecoratedCartFactory {
    90  			result := &decorator.DecoratedCartFactory{}
    91  			result.Inject(
    92  				nil,
    93  				flamingo.NullLogger{},
    94  			)
    95  
    96  			return result
    97  		}(),
    98  		nil,
    99  		new(flamingo.NullLogger),
   100  		nil,
   101  		nil,
   102  	)
   103  
   104  	for _, tt := range tests {
   105  		t.Run(tt.name, func(t *testing.T) {
   106  			cartService := application.CartService{}
   107  			cartService.Inject(
   108  				cartReceiverService,
   109  				nil,
   110  				nil,
   111  				nil,
   112  				nil,
   113  				nil,
   114  				nil,
   115  				new(flamingo.NullLogger),
   116  				nil,
   117  				&struct {
   118  					CartValidator     validation.Validator     `inject:",optional"`
   119  					ItemValidator     validation.ItemValidator `inject:",optional"`
   120  					CartCache         application.CartCache    `inject:",optional"`
   121  					PlaceOrderService placeorder.Service       `inject:",optional"`
   122  				}{CartValidator: &validator{Valid: tt.isValid}, ItemValidator: nil, CartCache: nil, PlaceOrderService: nil},
   123  			)
   124  			state := new(states.ValidateCart).Inject(&cartService)
   125  			p := &process.Process{}
   126  			cart := cartDomain.Cart{
   127  				ID:         "cart-id",
   128  				EntityID:   "entity-id",
   129  				GrandTotal: domain.NewFromInt(1, 1, "EUR"),
   130  			}
   131  
   132  			if tt.isGrandTotalZero {
   133  				cart.GrandTotal = domain.NewFromInt(0, 1, "EUR")
   134  			}
   135  
   136  			p.UpdateCart(cart)
   137  			p.UpdateState(state.Name(), nil)
   138  			ctx := web.ContextWithSession(context.Background(), web.EmptySession())
   139  			result := state.Run(ctx, p)
   140  
   141  			assert.Equal(t, tt.expectedState, p.Context().CurrentStateName, "Next state after ValidateCart should be CreatePayment.")
   142  			if diff := deep.Equal(result, tt.expectedResult); diff != nil {
   143  				t.Error("expected re is wrong: ", diff)
   144  			}
   145  		})
   146  	}
   147  
   148  }
   149  
   150  func TestValidateCart_IsFinal(t *testing.T) {
   151  	state := states.ValidateCart{}
   152  	assert.False(t, state.IsFinal())
   153  }