func TestPaymentListener(t *testing.T) {
mockEntityManager := new(mocks.MockEntityManager)
mockHorizon := new(mocks.MockHorizon)
mockRepository := new(mocks.MockRepository)
mockHTTPClient := new(mocks.MockHTTPClient)
config := &config.Config{
Assets: []config.Asset{
{Code: "USD", Issuer: "GD4I7AFSLZGTDL34TQLWJOM2NHLIIOEKD5RHHZUW54HERBLSIRKUOXRR"},
{Code: "EUR", Issuer: "GD4I7AFSLZGTDL34TQLWJOM2NHLIIOEKD5RHHZUW54HERBLSIRKUOXRR"},
},
Accounts: config.Accounts{
IssuingAccountID: "GATKP6ZQM5CSLECPMTAC5226PE367QALCPM6AFHTSULPPZMT62OOPMQB",
ReceivingAccountID: "GATKP6ZQM5CSLECPMTAC5226PE367QALCPM6AFHTSULPPZMT62OOPMQB",
},
Callbacks: config.Callbacks{
Receive: "http://receive_callback",
},
}
paymentListener, _ := NewPaymentListener(
config,
mockEntityManager,
mockHorizon,
mockRepository,
mocks.Now,
)
paymentListener.client = mockHTTPClient
Convey("PaymentListener", t, func() {
operation := horizon.PaymentResponse{
ID: "1",
From: "GBIHSMPXC2KJ3NJVHEYTG3KCHYEUQRT45X6AWYWXMAXZOAX4F5LFZYYQ",
PagingToken: "2",
Amount: "200",
}
mocks.PredefinedTime = time.Now()
dbPayment := entities.ReceivedPayment{
OperationID: operation.ID,
ProcessedAt: mocks.PredefinedTime,
PagingToken: operation.PagingToken,
}
Convey("When operation exists", func() {
operation.Type = "payment"
mockRepository.On("GetReceivedPaymentByID", int64(1)).Return(&entities.ReceivedPayment{}, nil).Once()
Convey("it should save the status", func() {
err := paymentListener.onPayment(operation)
assert.Nil(t, err)
mockEntityManager.AssertExpectations(t)
})
})
Convey("When operation is not a payment", func() {
operation.Type = "create_account"
dbPayment.Status = "Not a payment operation"
mockEntityManager.On("Persist", &dbPayment).Return(nil).Once()
mockRepository.On("GetReceivedPaymentByID", int64(1)).Return(nil, nil).Once()
Convey("it should save the status", func() {
err := paymentListener.onPayment(operation)
assert.Nil(t, err)
mockEntityManager.AssertExpectations(t)
})
})
Convey("When payment is sent not received", func() {
operation.Type = "payment"
operation.To = "GDNXBMIJLLLXZYKZBHXJ45WQ4AJQBRVT776YKGQTDBHTSPMNAFO3OZOS"
dbPayment.Status = "Operation sent not received"
mockEntityManager.On("Persist", &dbPayment).Return(nil).Once()
mockRepository.On("GetReceivedPaymentByID", int64(1)).Return(nil, nil).Once()
Convey("it should save the status", func() {
err := paymentListener.onPayment(operation)
assert.Nil(t, err)
mockEntityManager.AssertExpectations(t)
})
})
Convey("When asset is not allowed (issuer)", func() {
operation.Type = "payment"
operation.To = "GATKP6ZQM5CSLECPMTAC5226PE367QALCPM6AFHTSULPPZMT62OOPMQB"
operation.AssetCode = "USD"
operation.AssetIssuer = "GC4WWLMUGZJMRVJM7JUVVZBY3LJ5HL4RKIPADEGKEMLAAJEDRONUGYG7"
dbPayment.Status = "Asset not allowed"
mockEntityManager.On("Persist", &dbPayment).Return(nil).Once()
mockRepository.On("GetReceivedPaymentByID", int64(1)).Return(nil, nil).Once()
Convey("it should save the status", func() {
err := paymentListener.onPayment(operation)
assert.Nil(t, err)
mockEntityManager.AssertExpectations(t)
})
})
Convey("When asset is not allowed (code)", func() {
operation.Type = "payment"
operation.To = "GATKP6ZQM5CSLECPMTAC5226PE367QALCPM6AFHTSULPPZMT62OOPMQB"
operation.AssetCode = "GBP"
operation.AssetIssuer = "GD4I7AFSLZGTDL34TQLWJOM2NHLIIOEKD5RHHZUW54HERBLSIRKUOXRR"
dbPayment.Status = "Asset not allowed"
mockEntityManager.On("Persist", &dbPayment).Return(nil).Once()
mockRepository.On("GetReceivedPaymentByID", int64(1)).Return(nil, nil).Once()
Convey("it should save the status", func() {
err := paymentListener.onPayment(operation)
assert.Nil(t, err)
mockEntityManager.AssertExpectations(t)
})
})
Convey("When unable to load transaction memo", func() {
operation.Type = "payment"
operation.To = "GATKP6ZQM5CSLECPMTAC5226PE367QALCPM6AFHTSULPPZMT62OOPMQB"
operation.AssetCode = "USD"
operation.AssetIssuer = "GD4I7AFSLZGTDL34TQLWJOM2NHLIIOEKD5RHHZUW54HERBLSIRKUOXRR"
mockRepository.On("GetReceivedPaymentByID", int64(1)).Return(nil, nil).Once()
mockHorizon.On("LoadMemo", &operation).Return(errors.New("Connection error")).Once()
Convey("it should return error", func() {
err := paymentListener.onPayment(operation)
assert.Error(t, err)
mockHorizon.AssertExpectations(t)
mockEntityManager.AssertNotCalled(t, "Persist")
})
})
Convey("When receive callback returns error", func() {
operation.Type = "payment"
operation.To = "GATKP6ZQM5CSLECPMTAC5226PE367QALCPM6AFHTSULPPZMT62OOPMQB"
operation.AssetCode = "USD"
operation.AssetIssuer = "GD4I7AFSLZGTDL34TQLWJOM2NHLIIOEKD5RHHZUW54HERBLSIRKUOXRR"
operation.Memo.Type = "text"
operation.Memo.Value = "testing"
mockRepository.On("GetReceivedPaymentByID", int64(1)).Return(nil, nil).Once()
mockHorizon.On("LoadMemo", &operation).Return(nil).Once()
mockHTTPClient.On(
"PostForm",
"http://receive_callback",
url.Values{
"id": {"1"},
"from": {"GBIHSMPXC2KJ3NJVHEYTG3KCHYEUQRT45X6AWYWXMAXZOAX4F5LFZYYQ"},
"amount": {"200"},
"asset_code": {"USD"},
"memo_type": {"text"},
"memo": {"testing"},
"data": {""},
},
).Return(
net.BuildHTTPResponse(503, "ok"),
nil,
).Once()
Convey("it should save the status", func() {
err := paymentListener.onPayment(operation)
assert.Error(t, err)
mockHorizon.AssertExpectations(t)
mockEntityManager.AssertNotCalled(t, "Persist")
})
})
Convey("When receive callback returns success", func() {
operation.Type = "payment"
operation.To = "GATKP6ZQM5CSLECPMTAC5226PE367QALCPM6AFHTSULPPZMT62OOPMQB"
operation.AssetCode = "USD"
operation.AssetIssuer = "GD4I7AFSLZGTDL34TQLWJOM2NHLIIOEKD5RHHZUW54HERBLSIRKUOXRR"
operation.Memo.Type = "text"
operation.Memo.Value = "testing"
dbPayment.Status = "Success"
mockRepository.On("GetReceivedPaymentByID", int64(1)).Return(nil, nil).Once()
mockHorizon.On("LoadMemo", &operation).Return(nil).Once()
mockEntityManager.On("Persist", &dbPayment).Return(nil).Once()
mockHTTPClient.On(
"PostForm",
"http://receive_callback",
url.Values{
"id": {"1"},
"from": {"GBIHSMPXC2KJ3NJVHEYTG3KCHYEUQRT45X6AWYWXMAXZOAX4F5LFZYYQ"},
"amount": {"200"},
"asset_code": {"USD"},
"memo_type": {"text"},
"memo": {"testing"},
"data": {""},
},
).Return(
net.BuildHTTPResponse(200, "ok"),
nil,
).Once()
Convey("it should save the status", func() {
err := paymentListener.onPayment(operation)
assert.Nil(t, err)
mockHorizon.AssertExpectations(t)
mockEntityManager.AssertExpectations(t)
})
})
Convey("When receive callback returns success (no memo)", func() {
operation.Type = "payment"
operation.To = "GATKP6ZQM5CSLECPMTAC5226PE367QALCPM6AFHTSULPPZMT62OOPMQB"
operation.AssetCode = "USD"
operation.AssetIssuer = "GD4I7AFSLZGTDL34TQLWJOM2NHLIIOEKD5RHHZUW54HERBLSIRKUOXRR"
dbPayment.Status = "Success"
mockRepository.On("GetReceivedPaymentByID", int64(1)).Return(nil, nil).Once()
mockHorizon.On("LoadMemo", &operation).Return(nil).Once()
mockEntityManager.On("Persist", &dbPayment).Return(nil).Once()
mockHTTPClient.On(
"PostForm",
"http://receive_callback",
url.Values{
"id": {"1"},
"from": {"GBIHSMPXC2KJ3NJVHEYTG3KCHYEUQRT45X6AWYWXMAXZOAX4F5LFZYYQ"},
"amount": {"200"},
"asset_code": {"USD"},
"memo_type": {""},
"memo": {""},
"data": {""},
},
).Return(
net.BuildHTTPResponse(200, "ok"),
nil,
).Once()
Convey("it should save the status", func() {
err := paymentListener.onPayment(operation)
assert.Nil(t, err)
mockHorizon.AssertExpectations(t)
mockEntityManager.AssertExpectations(t)
})
})
Convey("When receive callback returns success and compliance server is connected", func() {
paymentListener.config.Compliance = "http://compliance"
operation.Type = "payment"
operation.To = "GATKP6ZQM5CSLECPMTAC5226PE367QALCPM6AFHTSULPPZMT62OOPMQB"
operation.AssetCode = "USD"
operation.AssetIssuer = "GD4I7AFSLZGTDL34TQLWJOM2NHLIIOEKD5RHHZUW54HERBLSIRKUOXRR"
operation.Memo.Type = "hash"
operation.Memo.Value = "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"
dbPayment.Status = "Success"
mockRepository.On("GetReceivedPaymentByID", int64(1)).Return(nil, nil).Once()
mockHorizon.On("LoadMemo", &operation).Return(nil).Once()
mockEntityManager.On("Persist", &dbPayment).Return(nil).Once()
mockHTTPClient.On(
"PostForm",
"http://compliance/receive",
url.Values{"memo": {"b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"}},
).Return(
net.BuildHTTPResponse(200, "{\"data\": \"hello world\"}"),
nil,
).Once()
mockHTTPClient.On(
"PostForm",
"http://receive_callback",
url.Values{
"id": {"1"},
"from": {"GBIHSMPXC2KJ3NJVHEYTG3KCHYEUQRT45X6AWYWXMAXZOAX4F5LFZYYQ"},
"amount": {"200"},
"asset_code": {"USD"},
"memo_type": {"hash"},
"memo": {"b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9"},
"data": {"hello world"},
},
).Return(
net.BuildHTTPResponse(200, "ok"),
nil,
).Once()
Convey("it should save the status", func() {
err := paymentListener.onPayment(operation)
assert.Nil(t, err)
mockHorizon.AssertExpectations(t)
mockEntityManager.AssertExpectations(t)
})
})
})
}
func (pl PaymentListener) onPayment(payment horizon.PaymentResponse) (err error) {
pl.log.WithFields(logrus.Fields{"id": payment.ID}).Info("New received payment")
id, err := strconv.ParseInt(payment.ID, 10, 64)
if err != nil {
pl.log.WithFields(logrus.Fields{"err": err}).Error("Error converting ID to int64")
return err
}
existingPayment, err := pl.repository.GetReceivedPaymentByID(id)
if err != nil {
pl.log.WithFields(logrus.Fields{"err": err}).Error("Error checking if receive payment exists")
return err
}
if existingPayment != nil {
pl.log.WithFields(logrus.Fields{"id": payment.ID}).Info("Payment already exists")
return
}
dbPayment := entities.ReceivedPayment{
OperationID: payment.ID,
ProcessedAt: pl.now(),
PagingToken: payment.PagingToken,
}
savePayment := func(payment *entities.ReceivedPayment) (err error) {
err = pl.entityManager.Persist(payment)
return
}
if payment.Type != "payment" && payment.Type != "path_payment" {
dbPayment.Status = "Not a payment operation"
savePayment(&dbPayment)
return
}
if payment.To != pl.config.Accounts.ReceivingAccountID {
dbPayment.Status = "Operation sent not received"
savePayment(&dbPayment)
return nil
}
if !pl.isAssetAllowed(payment.AssetCode, payment.AssetIssuer) {
dbPayment.Status = "Asset not allowed"
savePayment(&dbPayment)
return nil
}
err = pl.horizon.LoadMemo(&payment)
if err != nil {
pl.log.Error("Unable to load transaction memo")
return err
}
var receiveResponse compliance.ReceiveResponse
// Request extra_memo from compliance server
if pl.config.Compliance != "" && payment.Memo.Type == "hash" {
resp, err := pl.client.PostForm(
pl.config.Compliance+"/receive",
url.Values{"memo": {string(payment.Memo.Value)}},
)
if err != nil {
pl.log.WithFields(logrus.Fields{"err": err}).Error("Error sending request to compliance server")
return err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
pl.log.Error("Error reading compliance server response")
return err
}
if resp.StatusCode != 200 {
pl.log.WithFields(logrus.Fields{
"status": resp.StatusCode,
"body": string(body),
}).Error("Error response from compliance server")
return err
}
err = json.Unmarshal([]byte(body), &receiveResponse)
if err != nil {
pl.log.WithFields(logrus.Fields{"err": err}).Error("Cannot unmarshal receiveResponse")
return err
}
}
resp, err := pl.client.PostForm(
pl.config.Callbacks.Receive,
url.Values{
"id": {payment.ID},
"from": {payment.From},
"amount": {payment.Amount},
"asset_code": {payment.AssetCode},
"memo_type": {payment.Memo.Type},
"memo": {payment.Memo.Value},
"data": {receiveResponse.Data},
},
)
if err != nil {
pl.log.Error("Error sending request to receive callback")
return err
}
if resp.StatusCode != 200 {
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
pl.log.Error("Error reading receive callback response")
return err
}
pl.log.WithFields(logrus.Fields{
"status": resp.StatusCode,
"body": string(body),
}).Error("Error response from receive callback")
return errors.New("Error response from receive callback")
}
dbPayment.Status = "Success"
err = savePayment(&dbPayment)
if err != nil {
pl.log.Error("Error saving payment to the DB")
return err
}
return nil
}
