github.com/condensat/bank-core@v0.1.0/database/query/swapinfo_test.go (about)

     1  // Copyright 2020 Condensat Tech. All rights reserved.
     2  // Use of this source code is governed by a MIT
     3  // license that can be found in the LICENSE file.
     4  
     5  package query
     6  
     7  import (
     8  	"reflect"
     9  	"testing"
    10  	"time"
    11  
    12  	"github.com/condensat/bank-core/database/model"
    13  	"github.com/condensat/bank-core/database/query/tests"
    14  )
    15  
    16  func TestAddSwapInfo(t *testing.T) {
    17  	const databaseName = "TestAddSwapInfo"
    18  	t.Parallel()
    19  
    20  	db := tests.Setup(databaseName, SwapModel())
    21  	defer tests.Teardown(db, databaseName)
    22  
    23  	swapRef, _ := AddSwap(db, model.SwapTypeAsk, 42, 101, 1.1, 102, 1.2)
    24  
    25  	type args struct {
    26  		swapID  model.SwapID
    27  		status  model.SwapStatus
    28  		payload model.Payload
    29  	}
    30  	tests := []struct {
    31  		name    string
    32  		args    args
    33  		want    model.SwapInfo
    34  		wantErr bool
    35  	}{
    36  		{"default", args{}, model.SwapInfo{}, true},
    37  		{"valid", args{swapRef.ID, model.SwapStatusAccepted, "payload"}, createSwapInfo(swapRef.ID, model.SwapStatusAccepted, "payload"), false},
    38  	}
    39  	for _, tt := range tests {
    40  		tt := tt // capture range variable
    41  		t.Run(tt.name, func(t *testing.T) {
    42  			got, err := AddSwapInfo(db, tt.args.swapID, tt.args.status, tt.args.payload)
    43  			if (err != nil) != tt.wantErr {
    44  				t.Errorf("AddSwapInfo() error = %v, wantErr %v", err, tt.wantErr)
    45  				return
    46  			}
    47  
    48  			if !tt.wantErr {
    49  				if got.Timestamp.IsZero() || got.Timestamp.After(time.Now()) {
    50  					t.Errorf("AddSwapInfo() wrong Timestamp %v", got.Timestamp)
    51  				}
    52  			}
    53  
    54  			if !tt.wantErr {
    55  				tt.want.ID = got.ID
    56  				tt.want.Timestamp = got.Timestamp
    57  			}
    58  
    59  			if !reflect.DeepEqual(got, tt.want) {
    60  				t.Errorf("AddSwapInfo() = %v, want %v", got, tt.want)
    61  			}
    62  		})
    63  	}
    64  }
    65  
    66  func TestGetSwapInfo(t *testing.T) {
    67  	const databaseName = "TestGetSwapInfo"
    68  	t.Parallel()
    69  
    70  	db := tests.Setup(databaseName, SwapModel())
    71  	defer tests.Teardown(db, databaseName)
    72  
    73  	swapRef, _ := AddSwap(db, model.SwapTypeAsk, 42, 101, 1.1, 102, 1.2)
    74  	swapInfoRef, _ := AddSwapInfo(db, swapRef.ID, model.SwapStatusAccepted, "payload")
    75  	if swapInfoRef.SwapID != swapRef.ID {
    76  		t.Errorf("AddSwapInfo() wrnong swapID = %v, wantErr %v", swapInfoRef.SwapID, swapRef.ID)
    77  		return
    78  	}
    79  
    80  	type args struct {
    81  		swapInfoID model.SwapInfoID
    82  	}
    83  	tests := []struct {
    84  		name    string
    85  		args    args
    86  		want    model.SwapInfo
    87  		wantErr bool
    88  	}{
    89  		{"default", args{}, model.SwapInfo{}, true},
    90  		{"valid", args{swapInfoRef.ID}, swapInfoRef, false},
    91  	}
    92  	for _, tt := range tests {
    93  		tt := tt // capture range variable
    94  		t.Run(tt.name, func(t *testing.T) {
    95  			got, err := GetSwapInfo(db, tt.args.swapInfoID)
    96  			if (err != nil) != tt.wantErr {
    97  				t.Errorf("GetSwapInfo() error = %v, wantErr %v", err, tt.wantErr)
    98  				return
    99  			}
   100  			if !reflect.DeepEqual(got, tt.want) {
   101  				t.Errorf("GetSwapInfo() = %v, want %v", got, tt.want)
   102  			}
   103  		})
   104  	}
   105  }
   106  
   107  func TestGetSwapInfoBySwapID(t *testing.T) {
   108  	const databaseName = "TestGetSwapInfoBySwapID"
   109  	t.Parallel()
   110  
   111  	db := tests.Setup(databaseName, SwapModel())
   112  	defer tests.Teardown(db, databaseName)
   113  
   114  	swapRef, _ := AddSwap(db, model.SwapTypeAsk, 42, 101, 1.1, 102, 1.2)
   115  	swapInfoRef, _ := AddSwapInfo(db, swapRef.ID, model.SwapStatusAccepted, "payload")
   116  	if swapInfoRef.SwapID != swapRef.ID {
   117  		t.Errorf("AddSwapInfo() wrnong swapID = %v, wantErr %v", swapInfoRef.SwapID, swapRef.ID)
   118  		return
   119  	}
   120  
   121  	type args struct {
   122  		swapID model.SwapID
   123  	}
   124  	tests := []struct {
   125  		name    string
   126  		args    args
   127  		want    model.SwapInfo
   128  		wantErr bool
   129  	}{
   130  		{"default", args{}, model.SwapInfo{}, true},
   131  		{"valid", args{swapRef.ID}, swapInfoRef, false},
   132  	}
   133  	for _, tt := range tests {
   134  		tt := tt // capture range variable
   135  		t.Run(tt.name, func(t *testing.T) {
   136  			got, err := GetSwapInfoBySwapID(db, tt.args.swapID)
   137  			if (err != nil) != tt.wantErr {
   138  				t.Errorf("GetSwapInfoBySwapID() error = %v, wantErr %v", err, tt.wantErr)
   139  				return
   140  			}
   141  			if !reflect.DeepEqual(got, tt.want) {
   142  				t.Errorf("GetSwapInfoBySwapID() = %v, want %v", got, tt.want)
   143  			}
   144  		})
   145  	}
   146  }
   147  
   148  func createSwapInfo(swapID model.SwapID, status model.SwapStatus, payload model.Payload) model.SwapInfo {
   149  	return model.SwapInfo{
   150  		SwapID:  swapID,
   151  		Status:  status,
   152  		Payload: payload,
   153  	}
   154  }