improved version for ProcessOrder

order.go

// You can edit this code!
// Click here and start typing.
package main

import (
	"errors"
	"fmt"
)

type OrderItem struct {
	Name string
}

type OrderStatus string

const (
	OrderStatusReadyToProcess OrderStatus = "readyToProcess"
	MaxItemsToProcess                     = 1
)

var (
	ErrOrderAlreadyProcessed  = errors.New("is already processed")
	ErrOrderTooManyItems      = errors.New("has too many items")
	ErrOrderNotReadyToProcess = errors.New("isn't ready to process")
)

type Order struct {
	Status      OrderStatus
	Number      string
	IsVerified  bool
	IsProcessed bool
	Items       []OrderItem
}

func Process(order *Order) error {
	if order == nil || order.IsVerified == false {
		return nil
	}

	if order.IsProcessed {
		return fmt.Errorf("the order %s %w", order.Number, ErrOrderAlreadyProcessed)
	}

	if len(order.Items) > MaxItemsToProcess {
		return fmt.Errorf("the order %s %w ", order.Number, ErrOrderTooManyItems)
	}

	if order.Status != OrderStatusReadyToProcess {
		return fmt.Errorf("the order %s %w ", order.Number, ErrOrderNotReadyToProcess)
	}

	order.IsProcessed = true
	return nil
}

func main() {
	allGood := true
	for _, testCase := range []struct {
		description string
		order       *Order
		isProcessed bool
		err         error
	}{
		{
			description: "success order processed",
			order:       &Order{IsVerified: true, Status: OrderStatusReadyToProcess},
			isProcessed: true,
			err:         nil,
		},
		{
			description: "order not verified",
			order:       &Order{IsVerified: false},
			isProcessed: false,
			err:         nil,
		},
		{
			description: "order nil value",
			order:       nil,
			isProcessed: false,
			err:         nil,
		},
		{
			description: "order already processed",
			order:       &Order{IsProcessed: true, IsVerified: true, Number: "123"},
			isProcessed: true,
			err:         ErrOrderAlreadyProcessed,
		},
		{
			description: "order with many items",
			order: &Order{
				IsVerified: true,
				Items: []OrderItem{
					{Name: "Item1"},
					{Name: "Item2"},
				},
			},
			isProcessed: false,
			err:         ErrOrderTooManyItems,
		},
		{
			description: "order not ready to process",
			order:       &Order{IsVerified: true},
			isProcessed: false,
			err:         ErrOrderNotReadyToProcess,
		},
	} {
		err := Process(testCase.order)
		if !errors.Is(err, testCase.err) {
			allGood = false
			fmt.Println("ops, error returned not expected")
		}
		if testCase.order == nil {
			continue
		}
		if testCase.order.IsProcessed != testCase.isProcessed {
			allGood = false
			fmt.Println("ops, the order was not processed as expected")
		}
	}

	if allGood {
		fmt.Println("All good with ProcessOrder function")
		return
	}
	fmt.Println("there are errors for  ProcessOrder function")
}

order_test.go

package main

import (
	"github.com/stretchr/testify/assert"
	"testing"
)

func TestProcess(t *testing.T) {
	for _, testCase := range []struct {
		description string
		order       *Order
		isProcessed bool
		err         error
	}{
		{
			description: "success order processed",
			order:       &Order{IsVerified: true, Status: OrderStatusReadyToProcess},
			isProcessed: true,
			err:         nil,
		},
		{
			description: "order not verified",
			order:       &Order{IsVerified: false},
			isProcessed: false,
			err:         nil,
		},
		{
			description: "order nil value",
			order:       nil,
			isProcessed: false,
			err:         nil,
		},
		{
			description: "order already processed",
			order:       &Order{IsProcessed: true, IsVerified: true, Number: "123"},
			isProcessed: true,
			err:         ErrOrderAlreadyProcessed,
		},
		{
			description: "order with many items",
			order: &Order{
				IsVerified: true,
				Items: []OrderItem{
					{Name: "Item1"},
					{Name: "Item2"},
				},
			},
			isProcessed: false,
			err:         ErrOrderTooManyItems,
		},
		{
			description:"order not ready to process",
			order: &Order{IsVerified: true},
			isProcessed: false,
			err:   ErrOrderNotReadyToProcess,
		},
	} {
		t.Run(testCase.description, func(t *testing.T) {
			err := Process(testCase.order)
			assert.ErrorIs(t, err, testCase.err)
			if testCase.order == nil {
				return
			}
			assert.Equal(t, testCase.isProcessed, testCase.order.IsProcessed)
		})
	}
}