all: move test files for disbursement under its own directory

While at it, compare the test response directly by overwriting
CustRefNumber and DisburseID.

1 files changed, 68 insertions, 53 deletions

diff --git a/client_test.go b/client_test.go
index 3db7dd2..a6ae299 100644
--- a/client_test.go
+++ b/client_test.go
@@ -12,36 +12,33 @@ import (
 
 func TestClient_CheckBalance(t *testing.T) {
 	var (
-		tdata   *test.Data
-		balance *Balance
-		err     error
-		exp     []byte
-		got     []byte
+		tdata      *test.Data
+		gotBalance *Balance
+		expBalance *Balance
+		err        error
+		exp        []byte
 	)
 
-	tdata, err = test.LoadData(`testdata/disbursement_checkbalance_test.txt`)
+	tdata, err = test.LoadData(`testdata/disbursement/checkbalance_test.txt`)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	balance, err = testClient.CheckBalance()
+	gotBalance, err = testClient.CheckBalance()
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	// Set the value to zero, since their value may be different on each
-	// run.
-	balance.Current.Scan(0)
-	balance.Effective.Scan(0)
-
-	got, err = json.MarshalIndent(balance, ``, `  `)
+	exp = tdata.Output[`response.json`]
+	err = json.Unmarshal(exp, &expBalance)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	exp = tdata.Output[`response.json`]
+	expBalance.Current = gotBalance.Current
+	expBalance.Effective = gotBalance.Effective
 
-	test.Assert(t, `CheckBalance`, string(exp), string(got))
+	test.Assert(t, `CheckBalance`, gotBalance, expBalance)
 }
 
 func TestClient_ClearingInquiry_sandbox(t *testing.T) {
@@ -121,8 +118,6 @@ func TestClient_ClearingTransfer_sandbox(t *testing.T) {
 }
 
 func TestClient_InquiryStatus_sandbox(t *testing.T) {
-	t.Skip(`This test require external call to server`)
-
 	var (
 		tdata *test.Data
 
@@ -202,78 +197,101 @@ func TestClient_InquiryStatus_sandbox(t *testing.T) {
 }
 
 func TestClient_RtolInquiry_sandbox(t *testing.T) {
-	t.Skip(`This test require external call to server`)
-
 	var (
-		inquiryReq RtolInquiry
 		err        error
 		tdata      *test.Data
-		inquiryRes *RtolInquiryResponse
+		reqInquiry *RtolInquiry
+		gotInquiry *RtolInquiryResponse
+		expInquiry *RtolInquiryResponse
+		rawb       []byte
 	)
 
-	tdata, err = test.LoadData(`testdata/disbursement_rtol_inquiry_test.txt`)
+	tdata, err = test.LoadData(`testdata/disbursement/rtol_inquiry_test.txt`)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = json.Unmarshal(tdata.Input[`request.json`], &inquiryReq)
+	rawb = tdata.Input[`request.json`]
+	err = json.Unmarshal(rawb, &reqInquiry)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	inquiryRes, err = testClient.RtolInquiry(&inquiryReq)
+	gotInquiry, err = testClient.RtolInquiry(reqInquiry)
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	// We cannot compare the response, because for each call to server
-	// it will return different CustRefNumber and DisburseID.
-
-	t.Logf(`inquiryRes: %+v`, inquiryRes)
-
-	test.Assert(t, `AccountName`, `Test Account`, inquiryRes.AccountName)
+	rawb = tdata.Output[`response.json`]
+	err = json.Unmarshal(rawb, &expInquiry)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// Set dynamic field values in expected response.
+	expInquiry.CustRefNumber = gotInquiry.CustRefNumber
+	expInquiry.DisburseID = gotInquiry.DisburseID
+	test.Assert(t, `RtolInquiry`, expInquiry, gotInquiry)
 }
 
 func TestClient_RtolTransfer_sandbox(t *testing.T) {
-	t.Skip(`This test require external call to server`)
-
 	var (
-		err         error
-		tdata       *test.Data
-		inquiryReq  *RtolInquiry
-		inquiryRes  *RtolInquiryResponse
-		transferReq *RtolTransfer
-		transferRes *RtolTransferResponse
+		err   error
+		tdata *test.Data
+
+		reqInquiry *RtolInquiry
+		gotInquiry *RtolInquiryResponse
+		expInquiry *RtolInquiryResponse
+
+		reqTransfer *RtolTransfer
+		gotTransfer *RtolTransferResponse
+		expTransfer *RtolTransferResponse
+
+		rawb []byte
 	)
 
-	tdata, err = test.LoadData(`testdata/disbursement_rtol_transfer_test.txt`)
+	tdata, err = test.LoadData(`testdata/disbursement/rtol_transfer_test.txt`)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	err = json.Unmarshal(tdata.Input[`request_inquiry.json`], &inquiryReq)
+	// Do inquiry ...
+
+	rawb = tdata.Input[`inquiry_request.json`]
+	err = json.Unmarshal(rawb, &reqInquiry)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	inquiryRes, err = testClient.RtolInquiry(inquiryReq)
+	gotInquiry, err = testClient.RtolInquiry(reqInquiry)
 	if err != nil {
 		t.Fatal(err)
 	}
 
-	transferReq = NewRtolTransfer(inquiryReq, inquiryRes)
-
-	transferRes, err = testClient.RtolTransfer(transferReq)
+	rawb = tdata.Output[`inquiry_response.json`]
+	err = json.Unmarshal(rawb, &expInquiry)
 	if err != nil {
 		t.Fatal(err)
 	}
+	expInquiry.CustRefNumber = gotInquiry.CustRefNumber
+	expInquiry.DisburseID = gotInquiry.DisburseID
+	test.Assert(t, `RtolInquiry`, expInquiry, gotInquiry)
 
-	// We cannot compare the response, because for each call to server
-	// it will return different CustRefNumber and DisburseID.
+	// Do transfer ...
 
-	t.Logf(`RtolTransfer response: %+v`, transferRes)
+	reqTransfer = NewRtolTransfer(reqInquiry, gotInquiry)
 
-	test.Assert(t, `AccountName`, `Test Account`, inquiryRes.AccountName)
+	gotTransfer, err = testClient.RtolTransfer(reqTransfer)
+	if err != nil {
+		t.Fatal(err)
+	}
+
+	rawb = tdata.Output[`transfer_response.json`]
+	err = json.Unmarshal(rawb, &expTransfer)
+	if err != nil {
+		t.Fatal(err)
+	}
+	expTransfer.CustRefNumber = gotTransfer.CustRefNumber
+	expTransfer.DisburseID = gotTransfer.DisburseID
+	test.Assert(t, `RtolTransfer`, expTransfer, gotTransfer)
 }
 
 func TestClient_ListBank(t *testing.T) {
@@ -285,7 +303,7 @@ func TestClient_ListBank(t *testing.T) {
 		got   []byte
 	)
 
-	tdata, err = test.LoadData(`testdata/disbursement_listbank_test.txt`)
+	tdata, err = test.LoadData(`testdata/disbursement/listbank_test.txt`)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -300,9 +318,6 @@ func TestClient_ListBank(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	t.Logf(`%s`, got)
-
 	exp = tdata.Output[`response.json`]
-
 	test.Assert(t, `ListBank`, string(exp), string(got))
 }