github.com/sttk/sabi@v0.5.0/txn_test.go (about)

     1  package sabi_test
     2  
     3  import (
     4  	"strings"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  
     9  	"github.com/sttk/sabi"
    10  )
    11  
    12  func TestRunTxn(t *testing.T) {
    13  	ClearDaxBase()
    14  	defer ClearDaxBase()
    15  
    16  	type ABDax interface {
    17  		GetAData() (string, sabi.Err)
    18  		SetBData(data string) sabi.Err
    19  	}
    20  
    21  	base := sabi.NewDaxBase()
    22  	base = struct {
    23  		sabi.DaxBase
    24  		AGetDax
    25  		BGetSetDax
    26  	}{
    27  		DaxBase:    base,
    28  		AGetDax:    AGetDax{Dax: base},
    29  		BGetSetDax: BGetSetDax{Dax: base},
    30  	}
    31  
    32  	aDs := NewADaxSrc()
    33  	bDs := NewBDaxSrc()
    34  
    35  	err := base.SetUpLocalDaxSrc("aaa", aDs)
    36  	assert.True(t, err.IsOk())
    37  	err = base.SetUpLocalDaxSrc("bbb", bDs)
    38  	assert.True(t, err.IsOk())
    39  
    40  	aDs.AMap["a"] = "hello"
    41  	err = sabi.RunTxn(base, func(dax ABDax) sabi.Err {
    42  		data, err := dax.GetAData()
    43  		if !err.IsOk() {
    44  			return err
    45  		}
    46  		data = strings.ToUpper(data)
    47  		err = dax.SetBData(data)
    48  		return err
    49  	})
    50  	assert.True(t, err.IsOk())
    51  	assert.Equal(t, bDs.BMap["b"], "HELLO")
    52  
    53  	log := Logs.Front()
    54  	if log.Value == "ADaxConn#Commit" {
    55  		assert.Equal(t, log.Value, "ADaxConn#Commit")
    56  		log = log.Next()
    57  		assert.Equal(t, log.Value, "BDaxConn#Commit")
    58  	} else {
    59  		assert.Equal(t, log.Value, "BDaxConn#Commit")
    60  		log = log.Next()
    61  		assert.Equal(t, log.Value, "ADaxConn#Commit")
    62  	}
    63  	log = log.Next()
    64  	if log.Value == "ADaxConn#Close" {
    65  		assert.Equal(t, log.Value, "ADaxConn#Close")
    66  		log = log.Next()
    67  		assert.Equal(t, log.Value, "BDaxConn#Close")
    68  	} else {
    69  		assert.Equal(t, log.Value, "BDaxConn#Close")
    70  		log = log.Next()
    71  		assert.Equal(t, log.Value, "ADaxConn#Close")
    72  	}
    73  	log = log.Next()
    74  	assert.Nil(t, log)
    75  }
    76  
    77  func TestRunTxn_failToCreateDaxConn(t *testing.T) {
    78  	ClearDaxBase()
    79  	defer ClearDaxBase()
    80  
    81  	WillFailToCreateBDaxConn = true
    82  
    83  	type ABDax interface {
    84  		GetAData() (string, sabi.Err)
    85  		SetBData(data string) sabi.Err
    86  	}
    87  
    88  	base := sabi.NewDaxBase()
    89  	base = struct {
    90  		sabi.DaxBase
    91  		AGetDax
    92  		BGetSetDax
    93  	}{
    94  		DaxBase:    base,
    95  		AGetDax:    AGetDax{Dax: base},
    96  		BGetSetDax: BGetSetDax{Dax: base},
    97  	}
    98  
    99  	aDs := NewADaxSrc()
   100  	bDs := NewBDaxSrc()
   101  
   102  	err := base.SetUpLocalDaxSrc("aaa", aDs)
   103  	assert.True(t, err.IsOk())
   104  	err = base.SetUpLocalDaxSrc("bbb", bDs)
   105  	assert.True(t, err.IsOk())
   106  
   107  	aDs.AMap["a"] = "hello"
   108  	err = sabi.RunTxn(base, func(dax ABDax) sabi.Err {
   109  		data, err := dax.GetAData()
   110  		if !err.IsOk() {
   111  			return err
   112  		}
   113  		data = strings.ToUpper(data)
   114  		err = dax.SetBData(data)
   115  		return err
   116  	})
   117  	assert.False(t, err.IsOk())
   118  	switch err.Reason().(type) {
   119  	case sabi.FailToCreateDaxConn:
   120  		reason := err.Reason().(sabi.FailToCreateDaxConn)
   121  		assert.Equal(t, reason.Name, "bbb")
   122  		cause := err.Cause().(sabi.Err)
   123  		switch cause.Reason().(type) {
   124  		case FailToCreateBDaxConn:
   125  		default:
   126  			assert.Fail(t, err.Error())
   127  		}
   128  	default:
   129  		assert.Fail(t, err.Error())
   130  	}
   131  	assert.Equal(t, bDs.BMap["b"], "")
   132  
   133  	assert.Equal(t, Logs.Front().Value, "ADaxConn#Rollback")
   134  	assert.Equal(t, Logs.Front().Next().Value, "ADaxConn#Close")
   135  }
   136  
   137  func TestRunTxn_failToCommitDaxConn(t *testing.T) {
   138  	ClearDaxBase()
   139  	defer ClearDaxBase()
   140  
   141  	WillFailToCommitBDaxConn = true
   142  
   143  	type ABDax interface {
   144  		GetAData() (string, sabi.Err)
   145  		SetBData(data string) sabi.Err
   146  	}
   147  
   148  	base := sabi.NewDaxBase()
   149  	base = struct {
   150  		sabi.DaxBase
   151  		AGetDax
   152  		BGetSetDax
   153  	}{
   154  		DaxBase:    base,
   155  		AGetDax:    AGetDax{Dax: base},
   156  		BGetSetDax: BGetSetDax{Dax: base},
   157  	}
   158  
   159  	aDs := NewADaxSrc()
   160  	bDs := NewBDaxSrc()
   161  
   162  	err := base.SetUpLocalDaxSrc("aaa", aDs)
   163  	assert.True(t, err.IsOk())
   164  	err = base.SetUpLocalDaxSrc("bbb", bDs)
   165  	assert.True(t, err.IsOk())
   166  
   167  	aDs.AMap["a"] = "hello"
   168  	err = sabi.RunTxn(base, func(dax ABDax) sabi.Err {
   169  		data, err := dax.GetAData()
   170  		if !err.IsOk() {
   171  			return err
   172  		}
   173  		data = strings.ToUpper(data)
   174  		err = dax.SetBData(data)
   175  		return err
   176  	})
   177  	assert.False(t, err.IsOk())
   178  
   179  	switch err.Reason().(type) {
   180  	case sabi.FailToCommitDaxConn:
   181  		reason := err.Reason().(sabi.FailToCommitDaxConn)
   182  		assert.Equal(t, len(reason.Errors), 1)
   183  		err = reason.Errors["bbb"]
   184  		switch err.Reason().(type) {
   185  		case FailToCommitBDaxConn:
   186  		default:
   187  			assert.Fail(t, err.Error())
   188  		}
   189  	default:
   190  		assert.Fail(t, err.Error())
   191  	}
   192  
   193  	log := Logs.Front()
   194  	assert.Equal(t, log.Value, "ADaxConn#Commit")
   195  	log = log.Next()
   196  	if log.Value == "ADaxConn#Rollback" {
   197  		assert.Equal(t, log.Value, "ADaxConn#Rollback")
   198  		log = log.Next()
   199  		assert.Equal(t, log.Value, "BDaxConn#Rollback")
   200  	} else {
   201  		assert.Equal(t, log.Value, "BDaxConn#Rollback")
   202  		log = log.Next()
   203  		assert.Equal(t, log.Value, "ADaxConn#Rollback")
   204  	}
   205  	log = log.Next()
   206  	if log.Value == "ADaxConn#Close" {
   207  		assert.Equal(t, log.Value, "ADaxConn#Close")
   208  		log = log.Next()
   209  		assert.Equal(t, log.Value, "BDaxConn#Close")
   210  	} else {
   211  		assert.Equal(t, log.Value, "BDaxConn#Close")
   212  		log = log.Next()
   213  		assert.Equal(t, log.Value, "ADaxConn#Close")
   214  	}
   215  	log = log.Next()
   216  	assert.Nil(t, log)
   217  }
   218  
   219  func TestRunTxn_Run_errorInLogic(t *testing.T) {
   220  	ClearDaxBase()
   221  	defer ClearDaxBase()
   222  
   223  	WillFailToCommitBDaxConn = true
   224  
   225  	type ABDax interface {
   226  		GetAData() (string, sabi.Err)
   227  		SetBData(data string) sabi.Err
   228  	}
   229  
   230  	base := sabi.NewDaxBase()
   231  	base = struct {
   232  		sabi.DaxBase
   233  		AGetDax
   234  		BGetSetDax
   235  	}{
   236  		DaxBase:    base,
   237  		AGetDax:    AGetDax{Dax: base},
   238  		BGetSetDax: BGetSetDax{Dax: base},
   239  	}
   240  
   241  	aDs := NewADaxSrc()
   242  	bDs := NewBDaxSrc()
   243  
   244  	err := base.SetUpLocalDaxSrc("aaa", aDs)
   245  	assert.True(t, err.IsOk())
   246  	err = base.SetUpLocalDaxSrc("bbb", bDs)
   247  	assert.True(t, err.IsOk())
   248  
   249  	aDs.AMap["a"] = "hello"
   250  	err = sabi.RunTxn(base, func(dax ABDax) sabi.Err {
   251  		_, err = dax.GetAData()
   252  		if !err.IsOk() {
   253  			return err
   254  		}
   255  		return sabi.NewErr(FailToRunLogic{})
   256  	})
   257  	assert.False(t, err.IsOk())
   258  
   259  	switch err.Reason().(type) {
   260  	case FailToRunLogic:
   261  	default:
   262  		assert.Fail(t, err.Error())
   263  	}
   264  
   265  	log := Logs.Front()
   266  	assert.Equal(t, log.Value, "ADaxConn#Rollback")
   267  	log = log.Next()
   268  	assert.Equal(t, log.Value, "ADaxConn#Close")
   269  }