func Test_bartender_should_handle_order_and_check_validity_into_redis_with_success(t *testing.T) {
// given
order := commons.Order{Id: 1, Quantity: 5, Type: commons.Beer, CallBackUrl: "http://some-callback.com"}
bd, _ := json.Marshal(order)
// prepare datum into redis
c, _ := redis.Dial("tcp", redisAddr)
defer c.Close()
c.Do("SET", order.Id, string(bd))
defer c.Do("DEL", order.Id)
// start bartender
startBartender(b)
// when
resp, err := http.Post("http://127.0.0.1:4343/orders", "application/json", bytes.NewBuffer(bd))
assert.Nil(t, err)
assert.NotNil(t, resp)
assert.Equal(t, 200, resp.StatusCode)
val, _ := c.Do("GET", order.Id)
var upgOrder commons.Order
unmErr := commons.UnmarshalOrderFromInterface(val, &upgOrder)
if unmErr == nil {
assert.Equal(t, order.Id, upgOrder.Id)
assert.True(t, upgOrder.Valid)
} else {
t.Fatal(unmErr.Error())
}
}
func (b *Bartender) doHandleOrder(w http.ResponseWriter, r *http.Request, order commons.Order) {
log.Println(fmt.Sprintf("Bartender | receive one order : %s", order))
c, redisErr := redis.Dial("tcp", b.redisAddr)
defer c.Close()
if redisErr != nil {
log.Printf("An error happends : %s \n\r", redisErr.Error())
w.WriteHeader(500)
return
}
// check the existance of the order
exist, existErr := c.Do("EXISTS", order.Id)
if existErr != nil {
log.Printf("An error happends : %s \n\r", existErr.Error())
w.WriteHeader(500)
return
}
if exist.(int64) != 1 {
log.Printf("Any order founded for order %d \n\r", order.Id)
w.WriteHeader(404)
return
}
// get the existing order
var existingOrder commons.Order
data, getError := c.Do("GET", order.Id)
if getError != nil {
log.Printf("An error happends : %s \n\r", getError.Error())
w.WriteHeader(500)
return
}
// check that the order is not already validated
commons.UnmarshalOrderFromInterface(data, &existingOrder)
if existingOrder.Valid {
// already validated
log.Printf("Order with id %d is already validated \n\r", order.Id)
w.WriteHeader(403)
return
}
// register the validated
existingOrder.Valid = true
bd, marshalError := json.Marshal(existingOrder)
if marshalError != nil {
log.Printf("An error happends : %s \n\r", marshalError.Error())
w.WriteHeader(500)
return
}
d := time.Duration(int(math.Pow(float64(order.Type+1), 2.0))*order.Quantity) * time.Millisecond * 10
log.Println(fmt.Sprintf("Bartender | wait for %d millisecond", d))
time.Sleep(d)
_, saveErr := c.Do("SET", existingOrder.Id, string(bd))
if saveErr != nil {
log.Printf("An error happends : %s \n\r", saveErr.Error())
w.WriteHeader(500)
return
}
log.Println(fmt.Sprintf("Bartender | order %s successfully registered", order))
w.WriteHeader(200)
}
func paymentEndPoint(w http.ResponseWriter, r *http.Request) {
var order commons.Order
var credit commons.Credit
urlPart := strings.Split(r.URL.Path, "/")
// todo test me
if len(urlPart) < 3 {
log.Printf("payment | An error happends. Not enought variable path. Expected 3, get %d \n\r", len(urlPart))
w.WriteHeader(404)
return
}
c, redisErr := redis.Dial("tcp", redisAddr)
defer c.Close()
// todo test me
if redisErr != nil {
log.Printf("payment | An error happends : %s \n\r", redisErr.Error())
w.WriteHeader(500)
return
}
// check the existance of the order
exist, existErr := c.Do("EXISTS", urlPart[3])
if existErr != nil {
log.Printf("An error happends : %s \n\r", existErr.Error())
w.WriteHeader(500)
return
}
// todo test me
if exist.(int64) != 1 {
log.Printf("Any order founded for order %d \n\r", urlPart[3])
w.WriteHeader(404)
return
}
data, getError := c.Do("GET", urlPart[3])
if getError != nil {
log.Printf("An error happends : %s \n\r", getError.Error())
w.WriteHeader(500)
return
}
// check that the order is not already validated
// todo test me
commons.UnmarshalOrderFromInterface(data, &order)
if !order.Valid {
// not validated
log.Printf("Order with id %d is not validated \n\r", order.Id)
w.WriteHeader(403)
return
}
c.Do("DEL", order.Id)
// check the existance of the order
existCredit, _ := c.Do("EXISTS", urlPart[2])
// todo test me
if existCredit.(int64) != 1 {
credit = commons.Credit{PlayerId: urlPart[2], Score: computePaymentSum(order), Timestamp: int(time.Now().UTC().Unix())}
} else {
dataCred, _ := c.Do("GET", urlPart[2])
commons.UnmarshallCreditFromInterface(dataCred, &credit)
credit.Score += computePaymentSum(order)
}
bd, _ := json.Marshal(credit)
_, saveErr := c.Do("SET", credit.PlayerId, string(bd))
if saveErr != nil {
log.Printf("An error happends : %s \n\r", saveErr.Error())
w.WriteHeader(500)
return
}
log.Println(fmt.Sprintf("payment | credit %s successfully registered", credit))
func() {
ch <- commons.Notification{PlayerId: credit.PlayerId, Type: commons.Score, Score: credit.Score, Rate: float64(credit.Score) / float64((int(time.Now().UTC().Unix()) - credit.Timestamp))}
}()
w.WriteHeader(200)
}