Unmarshal transaction processor response code when empty

What
===
Added a type for the ProcessorResponseCode on Transaction that
unmarshals itself and considers an empty XML tag as zero.

Why
===
In some situations, e.g. a gateway reject, the processor response code
field will be an empty string. The processor response code field on
transaction is an int, but the default xml decoder will error when
unmarshaling an empty string into an int.

Why not nullable.NullInt64
===
In most places we've used `nullable.NullInt64` which is a struct that
wraps an Int64 to solve a similar problem. In the case of the processor
response code this has been a well established part of the API and
changing it from a builtin int to a struct would be more disruptive to
existing integrations than to a type with an underlying type of int.

Author: leighmcculloch

processor_response_code.go

@@ -0,0 +1,33 @@
+package braintree
+
+import "strconv"
+
+type ProcessorResponseCode int
+
+func (rc ProcessorResponseCode) Int() int {
+	return int(rc)
+}
+
+// UnmarshalText fills the response code with the integer value if the text contains one in string form. If the text is zero length, the response code's value is unchanged but unmarshaling is successful.
+func (rc *ProcessorResponseCode) UnmarshalText(text []byte) error {
+	if len(text) == 0 {
+		return nil
+	}
+
+	n, err := strconv.Atoi(string(text))
+	if err != nil {
+		return err
+	}
+
+	*rc = ProcessorResponseCode(n)
+
+	return nil
+}
+
+// MarshalText returns a string in bytes of the number, or nil in the case it is zero.
+func (rc ProcessorResponseCode) MarshalText() ([]byte, error) {
+	if rc == 0 {
+		return nil, nil
+	}
+	return []byte(strconv.Itoa(int(rc))), nil
+}

transaction.go

@@ -32,7 +32,7 @@ type Transaction struct {
 	RefundId                    string                    `xml:"refund-id,omitempty"`
 	RefundIds                   *[]string                 `xml:"refund-ids>item,omitempty"`
 	RefundedTransactionId       *string                   `xml:"refunded-transaction-id,omitempty"`
-	ProcessorResponseCode       int                       `xml:"processor-response-code,omitempty"`
+	ProcessorResponseCode       ProcessorResponseCode     `xml:"processor-response-code,omitempty"`
 	ProcessorResponseText       string                    `xml:"processor-response-text,omitempty"`
 	ProcessorAuthorizationCode  string                    `xml:"processor-authorization-code,omitempty"`
 	SettlementBatchId           string                    `xml:"settlement-batch-id,omitempty"`

transaction_integration_test.go

@@ -214,6 +214,37 @@ func TestTransactionCreateWhenGatewayRejected(t *testing.T) {
 	}
 }
 
+func TestTransactionCreateWhenGatewayRejectedFraud(t *testing.T) {
+	t.Parallel()
+
+	_, err := testGateway.Transaction().Create(&Transaction{
+		Type:               "sale",
+		Amount:             NewDecimal(201000, 2),
+		PaymentMethodNonce: FakeNonceGatewayRejectedFraud,
+	})
+	if err == nil {
+		t.Fatal("Did not receive error when creating invalid transaction")
+	}
+
+	if err.Error() != "Gateway Rejected: fraud" {
+		t.Fatal(err)
+	}
+
+	txnID := err.(*BraintreeError).Transaction.Id
+	txn, err := testGateway.Transaction().Find(txnID)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	if txn.Status != "gateway_rejected" {
+		t.Fatalf("Got status %q, want %q", txn.Status, "gateway_rejected")
+	}
+
+	if txn.ProcessorResponseCode != 0 {
+		t.Fatalf("Got processor response code %q, want %q", txn.ProcessorResponseCode, 0)
+	}
+}
+
 func TestFindTransaction(t *testing.T) {
 	t.Parallel()