func (engine *Engine) CreateOrder(order *data.Order) error {
if order.ID != 0 {
return ErrNonEmptyID
}
if order.State == "" {
order.State = data.OrderStateDraft
} else if order.State != data.OrderStateDraft {
return ErrNotDraft
}
if order.Time == 0 {
order.Time = uint64(time.Now().UTC().Unix())
} else if order.Time < uint64(time.Now().UTC().Add(-PastTimeTreshold).Unix()) {
return ErrIsPast
}
tx, err := engine.storage.Begin()
if err != nil {
return err
}
if err := tx.CreateOrder(order); err != nil {
return tx.Rollback(err)
}
populate.Order(order)
if err := tx.Commit(); err != nil {
return err
}
return nil
}
func TestForestOrderItemCreateOrderPlaced(t *testing.T) {
productInOrder := data.Product{
Name: generateName("Product"),
Price: data.Price{
Vat: 20,
Net: 100,
},
}
createProduct(&productInOrder)
product := data.Product{
Name: generateName("Product"),
Price: data.Price{
Vat: 20,
Net: 100,
},
}
createProduct(&product)
order := data.Order{
Items: []data.OrderItem{
data.OrderItem{
Product: productInOrder,
Quantity: 1,
},
},
}
createOrder(&order)
order.State = data.OrderStatePlaced
updateOrder(&order)
payload := data.OrderItem{
Product: data.Product{
ID: product.ID,
},
Quantity: 0,
}
got := Error{}
r := getForestClient().POST(t, forest.Path("/orders/{orderID}/items/{}", order.ID, "").Content(payload, MimeJSON))
// TODO:
// forest.ExpectStatus(t, r, http.StatusForbidden)
forest.ExpectStatus(t, r, http.StatusInternalServerError)
forest.ExpectJSONDocument(t, r, &got)
if got.Message == "" {
t.Error("Got empty error message")
}
}
func (engine *Engine) UpdateOrder(order *data.Order) error {
if order.ID == 0 {
return ErrEmptyID
}
tx, err := engine.storage.Begin()
if err != nil {
return err
}
existingOrder := &data.Order{
ID: order.ID,
}
if err := tx.LoadOrder(existingOrder); err != nil {
return tx.Rollback(err)
}
if order.Time == 0 {
order.Time = existingOrder.Time
} else if order.Time < uint64(time.Now().UTC().Add(-PastTimeTreshold).Unix()) {
return tx.Rollback(ErrIsPast)
}
if order.State == "" {
order.State = existingOrder.State
} else if order.State != existingOrder.State {
if existingOrder.State != data.OrderStateDraft {
return tx.Rollback(ErrNotDraft)
}
switch order.State {
case data.OrderStatePlaced:
if len(existingOrder.Items) < 1 {
return tx.Rollback(ErrOrderEmpty)
}
case data.OrderStateCancelled:
default:
return tx.Rollback(ErrUnknownState)
}
}
if err := tx.UpdateOrder(order); err != nil {
return tx.Rollback(err)
}
populate.Order(order)
if err := tx.Commit(); err != nil {
return err
}
return nil
}
func TestForestRemoveOrderItemOrderPlaced(t *testing.T) {
productInOrder := data.Product{
Name: generateName("Product"),
Price: data.Price{
Vat: 20,
Net: 100,
},
}
createProduct(&productInOrder)
product := data.Product{
Name: generateName("Product"),
Price: data.Price{
Vat: 20,
Net: 100,
},
}
createProduct(&product)
order := data.Order{
Items: []data.OrderItem{
data.OrderItem{
Product: productInOrder,
Quantity: 1,
},
},
}
createOrder(&order)
order.State = data.OrderStatePlaced
updateOrder(&order)
got := Error{}
r := getForestClient().DELETE(t, forest.Path("/orders/{orderID}/items/{productID}", order.ID, product.ID))
// TODO:
// forest.ExpectStatus(t, r, http.StatusNotFound)
forest.ExpectStatus(t, r, http.StatusInternalServerError)
forest.ExpectJSONDocument(t, r, &got)
if got.Message == "" {
t.Error("Got empty error message")
}
}
func TestForestUpdateOrderInvalidStateTransition(t *testing.T) {
invalidTransitions := [][2]string{
// [2]string{data.OrderStateDraft, data.OrderStatePlaced}, // valid
// [2]string{data.OrderStateDraft, data.OrderStateCancelled}, // valid
[2]string{data.OrderStatePlaced, data.OrderStateDraft},
[2]string{data.OrderStatePlaced, data.OrderStateCancelled},
[2]string{data.OrderStateCancelled, data.OrderStateDraft},
[2]string{data.OrderStateCancelled, data.OrderStatePlaced},
[2]string{data.OrderStateDraft, "UNKNOWN"},
[2]string{data.OrderStatePlaced, "UNKNOWN"},
[2]string{data.OrderStateCancelled, "UNKNOWN"},
}
product := data.Product{
Name: generateName("Product"),
Price: data.Price{
Vat: 20,
Net: 100,
},
}
createProduct(&product)
for _, invalidTransition := range invalidTransitions {
fromState, toState := invalidTransition[0], invalidTransition[1]
order := data.Order{
Items: []data.OrderItem{
data.OrderItem{
Product: product,
Quantity: 1,
},
},
}
createOrder(&order)
if fromState != order.State {
order.State = fromState
updateOrder(&order)
}
payload := data.Order{
State: toState,
}
got := Error{}
r := getForestClient().PUT(t, forest.Path("/orders/{id}", order.ID).Content(payload, MimeJSON))
// TODO:
// forest.ExpectStatus(t, r, http.StatusBadRequest)
forest.ExpectStatus(t, r, http.StatusInternalServerError)
forest.ExpectJSONDocument(t, r, &got)
if got.Message == "" {
t.Error("Got empty error message")
}
}
}