Extracted method core.GetOrder(), added unit test for it

Author: ozamiatin

api/jsonapi.go

@@ -1637,53 +1637,12 @@ func (i *jsonAPIHandler) POSTResyncBlockchain(w http.ResponseWriter, r *http.Req
 
 func (i *jsonAPIHandler) GETOrder(w http.ResponseWriter, r *http.Request) {
 	_, orderID := path.Split(r.URL.Path)
-	var (
-		err         error
-		isSale      bool
-		contract    *pb.RicardianContract
-		state       pb.OrderState
-		funded      bool
-		records     []*wallet.TransactionRecord
-		read        bool
-		paymentCoin *repo.CurrencyCode
-	)
-	contract, state, funded, records, read, paymentCoin, err = i.node.Datastore.Purchases().GetByOrderId(orderID)
-	if err != nil {
-		contract, state, funded, records, read, paymentCoin, err = i.node.Datastore.Sales().GetByOrderId(orderID)
-		if err != nil {
-			ErrorResponse(w, http.StatusNotFound, "Order not found")
-			return
-		}
-		isSale = true
-	}
-	resp := new(pb.OrderRespApi)
-	resp.Contract = contract
-	resp.Funded = funded
-	resp.Read = read
-	resp.State = state
 
-	// TODO: Remove once broken contracts are migrated
-	lookupCoin := contract.BuyerOrder.Payment.Coin
-	_, err = repo.LoadCurrencyDefinitions().Lookup(lookupCoin)
-	if err != nil {
-		log.Warningf("invalid BuyerOrder.Payment.Coin (%s) on order (%s)", lookupCoin, orderID)
-		contract.BuyerOrder.Payment.Coin = paymentCoin.String()
-	}
-
-	paymentTxs, refundTx, err := i.node.BuildTransactionRecords(contract, records, state)
+	resp, err := i.node.GetOrder(orderID)
 	if err != nil {
-		ErrorResponse(w, http.StatusInternalServerError, err.Error())
-		return
-	}
-	resp.PaymentAddressTransactions = paymentTxs
-	resp.RefundAddressTransaction = refundTx
-
-	unread, err := i.node.Datastore.Chat().GetUnreadCount(orderID)
-	if err != nil {
-		ErrorResponse(w, http.StatusInternalServerError, err.Error())
+		ErrorResponse(w, http.StatusNotFound, "Order not found")
 		return
 	}
-	resp.UnreadChatMessages = uint64(unread)
 
 	m := jsonpb.Marshaler{
 		EnumsAsInts:  false,
@@ -1696,11 +1655,7 @@ func (i *jsonAPIHandler) GETOrder(w http.ResponseWriter, r *http.Request) {
 		ErrorResponse(w, http.StatusInternalServerError, err.Error())
 		return
 	}
-	if isSale {
-		i.node.Datastore.Sales().MarkAsRead(orderID)
-	} else {
-		i.node.Datastore.Purchases().MarkAsRead(orderID)
-	}
+
 	SanitizedResponseM(w, out, new(pb.OrderRespApi))
 }
 

core/order.go

@@ -78,6 +78,63 @@ const (
 	CryptocurrencyPurchasePaymentAddressMaxLength = 512
 )
 
+func (n *OpenBazaarNode) GetOrder(orderID string) (*pb.OrderRespApi, error) {
+	var (
+		err         error
+		isSale      bool
+		contract    *pb.RicardianContract
+		state       pb.OrderState
+		funded      bool
+		records     []*wallet.TransactionRecord
+		read        bool
+		paymentCoin *repo.CurrencyCode
+	)
+	contract, state, funded, records, read, paymentCoin, err = n.Datastore.Purchases().GetByOrderId(orderID)
+	if err != nil {
+		contract, state, funded, records, read, paymentCoin, err = n.Datastore.Sales().GetByOrderId(orderID)
+		if err != nil {
+			return nil, errors.New("order not found")
+		}
+		isSale = true
+	}
+	resp := new(pb.OrderRespApi)
+	resp.Contract = contract
+	resp.Funded = funded
+	resp.Read = read
+	resp.State = state
+
+	// TODO: Remove once broken contracts are migrated
+	lookupCoin := contract.BuyerOrder.Payment.Coin
+	_, err = repo.LoadCurrencyDefinitions().Lookup(lookupCoin)
+	if err != nil {
+		log.Warningf("invalid BuyerOrder.Payment.Coin (%s) on order (%s)", lookupCoin, orderID)
+		contract.BuyerOrder.Payment.Coin = paymentCoin.String()
+	}
+
+	paymentTxs, refundTx, err := n.BuildTransactionRecords(contract, records, state)
+	if err != nil {
+		log.Errorf(err.Error())
+		return nil, err
+	}
+	resp.PaymentAddressTransactions = paymentTxs
+	resp.RefundAddressTransaction = refundTx
+
+	unread, err := n.Datastore.Chat().GetUnreadCount(orderID)
+	if err != nil {
+		log.Errorf(err.Error())
+		return nil, err
+	}
+	resp.UnreadChatMessages = uint64(unread)
+
+	if isSale {
+		n.Datastore.Sales().MarkAsRead(orderID)
+	} else {
+		n.Datastore.Purchases().MarkAsRead(orderID)
+	}
+
+	return resp, nil
+}
+
 // Purchase - add ricardian contract
 func (n *OpenBazaarNode) Purchase(data *PurchaseData) (orderID string, paymentAddress string, paymentAmount uint64, vendorOnline bool, err error) {
 	contract, err := n.createContractWithOrder(data)

core/order_test.go

@@ -1,6 +1,8 @@
 package core_test
 
 import (
+	"github.com/OpenBazaar/openbazaar-go/test/factory"
+	"github.com/go-errors/errors"
 	"testing"
 
 	"github.com/OpenBazaar/openbazaar-go/core"
@@ -356,3 +358,27 @@ func TestOpenBazaarNode_CalculateOrderTotal(t *testing.T) {
 		t.Error("Calculated wrong order total")
 	}
 }
+
+func TestOpenBazaarNode_GetOrder(t *testing.T) {
+	node, err := test.NewNode()
+	if err != nil {
+		t.Error(err)
+	}
+
+	contract := factory.NewContract()
+	orderID, err := node.CalcOrderID(contract.BuyerOrder)
+	err = node.Datastore.Purchases().Put(orderID, *contract, pb.OrderState_AWAITING_PAYMENT, false)
+
+	orderResponse, err := node.GetOrder(orderID)
+	if err != nil {
+		t.Error(err)
+	}
+
+	if orderResponse.Funded {
+		t.Error(errors.New("Should not be funded"))
+	}
+
+	if orderResponse.State != pb.OrderState_AWAITING_PAYMENT {
+		t.Error(errors.New("Expected state OrderState_AWAITING_PAYMENT"))
+	}
+}