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

     1  package sabi_test
     2  
     3  import (
     4  	"fmt"
     5  	"testing"
     6  
     7  	"github.com/stretchr/testify/assert"
     8  
     9  	"github.com/sttk/sabi"
    10  )
    11  
    12  func TestAddGlobalDaxSrc(t *testing.T) {
    13  	ClearDaxBase()
    14  	defer ClearDaxBase()
    15  
    16  	assert.False(t, sabi.IsGlobalDaxSrcsFixed())
    17  	assert.Equal(t, len(sabi.GlobalDaxSrcMap()), 0)
    18  
    19  	sabi.AddGlobalDaxSrc("foo", FooDaxSrc{})
    20  
    21  	assert.False(t, sabi.IsGlobalDaxSrcsFixed())
    22  	assert.Equal(t, len(sabi.GlobalDaxSrcMap()), 1)
    23  
    24  	sabi.AddGlobalDaxSrc("bar", &BarDaxSrc{})
    25  
    26  	assert.False(t, sabi.IsGlobalDaxSrcsFixed())
    27  	assert.Equal(t, len(sabi.GlobalDaxSrcMap()), 2)
    28  }
    29  
    30  func TestStartUpGlobalDaxSrcs(t *testing.T) {
    31  	ClearDaxBase()
    32  	defer ClearDaxBase()
    33  
    34  	assert.False(t, sabi.IsGlobalDaxSrcsFixed())
    35  	assert.Equal(t, len(sabi.GlobalDaxSrcMap()), 0)
    36  
    37  	sabi.AddGlobalDaxSrc("foo", FooDaxSrc{})
    38  
    39  	assert.False(t, sabi.IsGlobalDaxSrcsFixed())
    40  	assert.Equal(t, len(sabi.GlobalDaxSrcMap()), 1)
    41  
    42  	err := sabi.StartUpGlobalDaxSrcs()
    43  	assert.True(t, err.IsOk())
    44  
    45  	assert.True(t, sabi.IsGlobalDaxSrcsFixed())
    46  	assert.Equal(t, len(sabi.GlobalDaxSrcMap()), 1)
    47  
    48  	sabi.AddGlobalDaxSrc("bar", &BarDaxSrc{})
    49  
    50  	assert.True(t, sabi.IsGlobalDaxSrcsFixed())
    51  	assert.Equal(t, len(sabi.GlobalDaxSrcMap()), 1)
    52  
    53  	log := Logs.Front()
    54  	assert.Equal(t, log.Value, "FooDaxSrc#SetUp")
    55  	assert.Nil(t, log.Next())
    56  }
    57  
    58  func TestStartUpGlobalDaxSrcs_failToSetUpDaxSrc(t *testing.T) {
    59  	ClearDaxBase()
    60  	defer ClearDaxBase()
    61  
    62  	WillFailToSetUpFooDaxSrc = true
    63  
    64  	assert.False(t, sabi.IsGlobalDaxSrcsFixed())
    65  	assert.Equal(t, len(sabi.GlobalDaxSrcMap()), 0)
    66  
    67  	sabi.AddGlobalDaxSrc("bar", &BarDaxSrc{})
    68  
    69  	assert.False(t, sabi.IsGlobalDaxSrcsFixed())
    70  	assert.Equal(t, len(sabi.GlobalDaxSrcMap()), 1)
    71  
    72  	sabi.AddGlobalDaxSrc("foo", FooDaxSrc{})
    73  
    74  	assert.False(t, sabi.IsGlobalDaxSrcsFixed())
    75  	assert.Equal(t, len(sabi.GlobalDaxSrcMap()), 2)
    76  
    77  	err := sabi.StartUpGlobalDaxSrcs()
    78  	assert.False(t, err.IsOk())
    79  	switch err.Reason().(type) {
    80  	case sabi.FailToStartUpGlobalDaxSrcs:
    81  		errs := err.Reason().(sabi.FailToStartUpGlobalDaxSrcs).Errors
    82  		assert.Equal(t, len(errs), 1)
    83  		err1 := errs["foo"]
    84  		r := err1.Reason().(FailToDoSomething)
    85  		assert.Equal(t, r.Text, "FailToSetUpFooDaxSrc")
    86  	default:
    87  		assert.Fail(t, err.Error())
    88  	}
    89  
    90  	log := Logs.Front()
    91  	assert.Equal(t, log.Value, "BarDaxSrc#SetUp")
    92  	log = log.Next()
    93  	if log.Value == "FooDaxSrc#End" {
    94  		assert.Equal(t, log.Value, "FooDaxSrc#End")
    95  		log = log.Next()
    96  		assert.Equal(t, log.Value, "BarDaxSrc#End")
    97  	} else {
    98  		assert.Equal(t, log.Value, "BarDaxSrc#End")
    99  		log = log.Next()
   100  		assert.Equal(t, log.Value, "FooDaxSrc#End")
   101  	}
   102  	assert.Nil(t, log.Next())
   103  }
   104  
   105  func TestShutdownGlobalDaxSrcs(t *testing.T) {
   106  	ClearDaxBase()
   107  	defer ClearDaxBase()
   108  
   109  	assert.False(t, sabi.IsGlobalDaxSrcsFixed())
   110  	assert.Equal(t, len(sabi.GlobalDaxSrcMap()), 0)
   111  
   112  	sabi.AddGlobalDaxSrc("foo", FooDaxSrc{})
   113  
   114  	assert.False(t, sabi.IsGlobalDaxSrcsFixed())
   115  	assert.Equal(t, len(sabi.GlobalDaxSrcMap()), 1)
   116  
   117  	sabi.AddGlobalDaxSrc("bar", &BarDaxSrc{})
   118  
   119  	assert.False(t, sabi.IsGlobalDaxSrcsFixed())
   120  	assert.Equal(t, len(sabi.GlobalDaxSrcMap()), 2)
   121  
   122  	err := sabi.StartUpGlobalDaxSrcs()
   123  	assert.True(t, err.IsOk())
   124  
   125  	assert.True(t, sabi.IsGlobalDaxSrcsFixed())
   126  	assert.Equal(t, len(sabi.GlobalDaxSrcMap()), 2)
   127  
   128  	sabi.ShutdownGlobalDaxSrcs()
   129  
   130  	assert.True(t, sabi.IsGlobalDaxSrcsFixed())
   131  	assert.Equal(t, len(sabi.GlobalDaxSrcMap()), 2)
   132  
   133  	log := Logs.Front()
   134  	if log.Value == "FooDaxSrc#SetUp" {
   135  		assert.Equal(t, log.Value, "FooDaxSrc#SetUp")
   136  		log = log.Next()
   137  		assert.Equal(t, log.Value, "BarDaxSrc#SetUp")
   138  	} else {
   139  		assert.Equal(t, log.Value, "BarDaxSrc#SetUp")
   140  		log = log.Next()
   141  		assert.Equal(t, log.Value, "FooDaxSrc#SetUp")
   142  	}
   143  	log = log.Next()
   144  	if log.Value == "FooDaxSrc#End" {
   145  		assert.Equal(t, log.Value, "FooDaxSrc#End")
   146  		log = log.Next()
   147  		assert.Equal(t, log.Value, "BarDaxSrc#End")
   148  	} else {
   149  		assert.Equal(t, log.Value, "BarDaxSrc#End")
   150  		log = log.Next()
   151  		assert.Equal(t, log.Value, "FooDaxSrc#End")
   152  	}
   153  	assert.Nil(t, log.Next())
   154  }
   155  
   156  func TestDaxBase_SetUpLocalDaxSrc(t *testing.T) {
   157  	ClearDaxBase()
   158  	defer ClearDaxBase()
   159  
   160  	base := sabi.NewDaxBase()
   161  
   162  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   163  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 0)
   164  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   165  
   166  	base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   167  
   168  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   169  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 1)
   170  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   171  
   172  	base.SetUpLocalDaxSrc("bar", &BarDaxSrc{})
   173  
   174  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   175  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 2)
   176  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   177  
   178  	log := Logs.Front()
   179  	assert.Equal(t, log.Value, "FooDaxSrc#SetUp")
   180  	log = log.Next()
   181  	assert.Equal(t, log.Value, "BarDaxSrc#SetUp")
   182  	log = log.Next()
   183  	assert.Nil(t, log)
   184  }
   185  
   186  func TestDaxBase_SetUpLocalDaxSrc_unableToAddLocalDaxSrcInTxn(t *testing.T) {
   187  	ClearDaxBase()
   188  	defer ClearDaxBase()
   189  
   190  	base := sabi.NewDaxBase()
   191  
   192  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   193  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 0)
   194  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   195  
   196  	base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   197  
   198  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   199  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 1)
   200  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   201  
   202  	sabi.Begin(base)
   203  
   204  	assert.True(t, sabi.IsLocalDaxSrcsFixed(base))
   205  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 1)
   206  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   207  
   208  	base.SetUpLocalDaxSrc("bar", &BarDaxSrc{})
   209  
   210  	assert.True(t, sabi.IsLocalDaxSrcsFixed(base))
   211  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 1)
   212  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   213  
   214  	log := Logs.Front()
   215  	assert.Equal(t, log.Value, "FooDaxSrc#SetUp")
   216  	log = log.Next()
   217  	assert.Nil(t, log)
   218  
   219  	sabi.End(base)
   220  
   221  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   222  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 1)
   223  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   224  
   225  	base.SetUpLocalDaxSrc("bar", &BarDaxSrc{})
   226  
   227  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   228  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 2)
   229  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   230  
   231  	log = Logs.Front()
   232  	assert.Equal(t, log.Value, "FooDaxSrc#SetUp")
   233  	log = log.Next()
   234  	assert.Equal(t, log.Value, "BarDaxSrc#SetUp")
   235  	log = log.Next()
   236  	assert.Nil(t, log)
   237  }
   238  
   239  func TestDaxBase_SetUpLocalDaxSrc_failToSetUpDaxSrc(t *testing.T) {
   240  	ClearDaxBase()
   241  	defer ClearDaxBase()
   242  
   243  	WillFailToSetUpFooDaxSrc = true
   244  
   245  	base := sabi.NewDaxBase()
   246  
   247  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   248  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 0)
   249  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   250  
   251  	err := base.SetUpLocalDaxSrc("bar", BarDaxSrc{})
   252  	assert.True(t, err.IsOk())
   253  
   254  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   255  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 1)
   256  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   257  
   258  	err = base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   259  	assert.False(t, err.IsOk())
   260  
   261  	switch err.Reason().(type) {
   262  	case FailToDoSomething:
   263  		r := err.Reason().(FailToDoSomething)
   264  		assert.Equal(t, r.Text, "FailToSetUpFooDaxSrc")
   265  	default:
   266  		assert.Fail(t, err.Error())
   267  	}
   268  
   269  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   270  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 1)
   271  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   272  
   273  	base.FreeAllLocalDaxSrcs()
   274  
   275  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   276  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 0)
   277  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   278  
   279  	log := Logs.Front()
   280  	assert.Equal(t, log.Value, "BarDaxSrc#SetUp")
   281  	log = log.Next()
   282  	assert.Equal(t, log.Value, "BarDaxSrc#End")
   283  	assert.Nil(t, log.Next())
   284  }
   285  
   286  func TestDaxBase_FreeLocalDaxSrc(t *testing.T) {
   287  	ClearDaxBase()
   288  	defer ClearDaxBase()
   289  
   290  	base := sabi.NewDaxBase()
   291  
   292  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   293  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 0)
   294  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   295  
   296  	base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   297  
   298  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   299  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 1)
   300  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   301  
   302  	base.FreeLocalDaxSrc("foo")
   303  
   304  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   305  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 0)
   306  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   307  
   308  	base.SetUpLocalDaxSrc("bar", &BarDaxSrc{})
   309  
   310  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   311  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 1)
   312  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   313  
   314  	base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   315  
   316  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   317  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 2)
   318  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   319  
   320  	base.FreeLocalDaxSrc("bar")
   321  
   322  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   323  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 1)
   324  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   325  
   326  	base.FreeLocalDaxSrc("foo")
   327  
   328  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   329  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 0)
   330  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   331  
   332  	log := Logs.Front()
   333  	assert.Equal(t, log.Value, "FooDaxSrc#SetUp")
   334  	log = log.Next()
   335  	assert.Equal(t, log.Value, "FooDaxSrc#End")
   336  	log = log.Next()
   337  	assert.Equal(t, log.Value, "BarDaxSrc#SetUp")
   338  	log = log.Next()
   339  	assert.Equal(t, log.Value, "FooDaxSrc#SetUp")
   340  	log = log.Next()
   341  	assert.Equal(t, log.Value, "BarDaxSrc#End")
   342  	log = log.Next()
   343  	assert.Equal(t, log.Value, "FooDaxSrc#End")
   344  	log = log.Next()
   345  	assert.Nil(t, log)
   346  }
   347  
   348  func TestDaxBase_FreeLocalDaxSrc_unableToFreeLocalDaxSrcInTxn(t *testing.T) {
   349  	ClearDaxBase()
   350  	defer ClearDaxBase()
   351  
   352  	base := sabi.NewDaxBase()
   353  
   354  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   355  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 0)
   356  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   357  
   358  	base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   359  
   360  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   361  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 1)
   362  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   363  
   364  	sabi.Begin(base)
   365  
   366  	assert.True(t, sabi.IsLocalDaxSrcsFixed(base))
   367  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 1)
   368  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   369  
   370  	base.FreeLocalDaxSrc("foo")
   371  
   372  	assert.True(t, sabi.IsLocalDaxSrcsFixed(base))
   373  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 1)
   374  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   375  
   376  	sabi.End(base)
   377  
   378  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   379  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 1)
   380  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   381  
   382  	base.FreeLocalDaxSrc("foo")
   383  
   384  	assert.False(t, sabi.IsLocalDaxSrcsFixed(base))
   385  	assert.Equal(t, len(sabi.LocalDaxSrcMap(base)), 0)
   386  	assert.Equal(t, len(sabi.DaxConnMap(base)), 0)
   387  }
   388  
   389  func TestDaxBase_GetDaxConn_withLocalDaxSrc(t *testing.T) {
   390  	ClearDaxBase()
   391  	defer ClearDaxBase()
   392  
   393  	base := sabi.NewDaxBase()
   394  
   395  	conn, err := sabi.GetDaxConn[FooDaxConn](base, "foo")
   396  	switch err.Reason().(type) {
   397  	case sabi.DaxSrcIsNotFound:
   398  		assert.Equal(t, err.Get("Name"), "foo")
   399  	default:
   400  		assert.Fail(t, err.Error())
   401  	}
   402  
   403  	err = sabi.StartUpGlobalDaxSrcs()
   404  
   405  	conn, err = sabi.GetDaxConn[FooDaxConn](base, "foo")
   406  	switch err.Reason().(type) {
   407  	case sabi.DaxSrcIsNotFound:
   408  		assert.Equal(t, err.Get("Name"), "foo")
   409  	default:
   410  		assert.Fail(t, err.Error())
   411  	}
   412  
   413  	err = base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   414  
   415  	conn, err = sabi.GetDaxConn[FooDaxConn](base, "foo")
   416  	assert.NotNil(t, conn)
   417  	assert.True(t, err.IsOk())
   418  
   419  	var conn2 sabi.DaxConn
   420  	conn2, err = sabi.GetDaxConn[FooDaxConn](base, "foo")
   421  	assert.Equal(t, conn2, conn)
   422  	assert.True(t, err.IsOk())
   423  }
   424  
   425  func TestDaxBase_getDaxConn_withGlobalDaxSrc(t *testing.T) {
   426  	ClearDaxBase()
   427  	defer ClearDaxBase()
   428  
   429  	base := sabi.NewDaxBase()
   430  
   431  	conn, err := sabi.GetDaxConn[FooDaxConn](base, "foo")
   432  	switch err.Reason().(type) {
   433  	case sabi.DaxSrcIsNotFound:
   434  		assert.Equal(t, err.Get("Name"), "foo")
   435  	default:
   436  		assert.Fail(t, err.Error())
   437  	}
   438  
   439  	sabi.AddGlobalDaxSrc("foo", FooDaxSrc{})
   440  
   441  	err = sabi.StartUpGlobalDaxSrcs()
   442  	conn, err = sabi.GetDaxConn[FooDaxConn](base, "foo")
   443  	assert.NotNil(t, conn)
   444  	assert.True(t, err.IsOk())
   445  
   446  	var conn2 sabi.DaxConn
   447  	conn2, err = sabi.GetDaxConn[FooDaxConn](base, "foo")
   448  	assert.Equal(t, conn2, conn)
   449  	assert.True(t, err.IsOk())
   450  }
   451  
   452  func TestDaxBase_getDaxConn_localDsIsTakenPriorityOfGlobalDs(t *testing.T) {
   453  	ClearDaxBase()
   454  	defer ClearDaxBase()
   455  
   456  	base := sabi.NewDaxBase()
   457  
   458  	conn, err := sabi.GetDaxConn[FooDaxConn](base, "foo")
   459  	switch err.Reason().(type) {
   460  	case sabi.DaxSrcIsNotFound:
   461  		assert.Equal(t, err.Get("Name"), "foo")
   462  	default:
   463  		assert.Fail(t, err.Error())
   464  	}
   465  
   466  	sabi.AddGlobalDaxSrc("foo", FooDaxSrc{Label: "global"})
   467  
   468  	err = sabi.StartUpGlobalDaxSrcs()
   469  	assert.True(t, err.IsOk())
   470  
   471  	err = base.SetUpLocalDaxSrc("foo", FooDaxSrc{Label: "local"})
   472  	assert.True(t, err.IsOk())
   473  
   474  	conn, err = sabi.GetDaxConn[FooDaxConn](base, "foo")
   475  	assert.Equal(t, conn.Label, "local")
   476  	assert.True(t, err.IsOk())
   477  }
   478  
   479  func TestDaxBase_getDaxConn_failToCreateDaxConn(t *testing.T) {
   480  	ClearDaxBase()
   481  	defer ClearDaxBase()
   482  
   483  	WillFailToCreateFooDaxConn = true
   484  
   485  	base := sabi.NewDaxBase()
   486  
   487  	err := base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   488  
   489  	_, err = sabi.GetDaxConn[FooDaxConn](base, "foo")
   490  	switch err.Reason().(type) {
   491  	case sabi.FailToCreateDaxConn:
   492  		assert.Equal(t, err.Get("Name"), "foo")
   493  		switch err.Cause().(sabi.Err).Reason().(type) {
   494  		case FailToDoSomething:
   495  		default:
   496  			assert.Fail(t, err.Error())
   497  		}
   498  	default:
   499  		assert.Fail(t, err.Error())
   500  	}
   501  }
   502  
   503  func TestDaxBase_getDaxConn_commit(t *testing.T) {
   504  	ClearDaxBase()
   505  	defer ClearDaxBase()
   506  
   507  	base := sabi.NewDaxBase()
   508  
   509  	err := base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   510  	assert.True(t, err.IsOk())
   511  
   512  	err = base.SetUpLocalDaxSrc("bar", BarDaxSrc{})
   513  	assert.True(t, err.IsOk())
   514  
   515  	sabi.Begin(base)
   516  
   517  	var conn sabi.DaxConn
   518  	conn, err = sabi.GetDaxConn[FooDaxConn](base, "foo")
   519  	assert.NotNil(t, conn)
   520  	assert.True(t, err.IsOk())
   521  
   522  	conn, err = sabi.GetDaxConn[*BarDaxConn](base, "bar")
   523  	assert.NotNil(t, conn)
   524  	assert.True(t, err.IsOk())
   525  
   526  	err = sabi.Commit(base)
   527  	assert.True(t, err.IsOk())
   528  
   529  	log := Logs.Front()
   530  	assert.Equal(t, log.Value, "FooDaxSrc#SetUp")
   531  	log = log.Next()
   532  	assert.Equal(t, log.Value, "BarDaxSrc#SetUp")
   533  	log = log.Next()
   534  	assert.Equal(t, log.Value, "FooDaxSrc#CreateDaxConn")
   535  	log = log.Next()
   536  	assert.Equal(t, log.Value, "BarDaxSrc#CreateDaxConn")
   537  	log = log.Next()
   538  	if log.Value == "FooDaxConn#Commit" {
   539  		assert.Equal(t, log.Value, "FooDaxConn#Commit")
   540  		log = log.Next()
   541  		assert.Equal(t, log.Value, "BarDaxConn#Commit")
   542  	} else {
   543  		assert.Equal(t, log.Value, "BarDaxConn#Commit")
   544  		log = log.Next()
   545  		assert.Equal(t, log.Value, "FooDaxConn#Commit")
   546  	}
   547  	log = log.Next()
   548  	assert.Nil(t, log)
   549  }
   550  
   551  func TestDaxBase_getDaxConn_failToCommit(t *testing.T) {
   552  	ClearDaxBase()
   553  	defer ClearDaxBase()
   554  
   555  	WillFailToCommitFooDaxConn = true
   556  
   557  	base := sabi.NewDaxBase()
   558  
   559  	err := base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   560  	assert.True(t, err.IsOk())
   561  
   562  	err = base.SetUpLocalDaxSrc("bar", BarDaxSrc{})
   563  	assert.True(t, err.IsOk())
   564  
   565  	sabi.Begin(base)
   566  
   567  	var conn sabi.DaxConn
   568  	conn, err = sabi.GetDaxConn[FooDaxConn](base, "foo")
   569  	assert.NotNil(t, conn)
   570  	assert.True(t, err.IsOk())
   571  
   572  	conn, err = sabi.GetDaxConn[*BarDaxConn](base, "bar")
   573  	assert.NotNil(t, conn)
   574  	assert.True(t, err.IsOk())
   575  
   576  	err = sabi.Commit(base)
   577  	assert.False(t, err.IsOk())
   578  	switch err.Reason().(type) {
   579  	case sabi.FailToCommitDaxConn:
   580  		m := err.Get("Errors").(map[string]sabi.Err)
   581  		assert.Equal(t, m["foo"].ReasonName(), "FailToDoSomething")
   582  	default:
   583  		assert.Fail(t, err.Error())
   584  	}
   585  
   586  	log := Logs.Front()
   587  	assert.Equal(t, log.Value, "FooDaxSrc#SetUp")
   588  	log = log.Next()
   589  	assert.Equal(t, log.Value, "BarDaxSrc#SetUp")
   590  	log = log.Next()
   591  	assert.Equal(t, log.Value, "FooDaxSrc#CreateDaxConn")
   592  	log = log.Next()
   593  	assert.Equal(t, log.Value, "BarDaxSrc#CreateDaxConn")
   594  	log = log.Next()
   595  	assert.Equal(t, log.Value, "BarDaxConn#Commit")
   596  	log = log.Next()
   597  	assert.Nil(t, log)
   598  }
   599  
   600  func TestDaxBase_getDaxConn_rollback(t *testing.T) {
   601  	ClearDaxBase()
   602  	defer ClearDaxBase()
   603  
   604  	base := sabi.NewDaxBase()
   605  
   606  	err := base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   607  	assert.True(t, err.IsOk())
   608  	err = base.SetUpLocalDaxSrc("bar", BarDaxSrc{})
   609  	assert.True(t, err.IsOk())
   610  
   611  	sabi.Begin(base)
   612  
   613  	var conn sabi.DaxConn
   614  	conn, err = sabi.GetDaxConn[FooDaxConn](base, "foo")
   615  	assert.NotNil(t, conn)
   616  	assert.True(t, err.IsOk())
   617  
   618  	conn, err = sabi.GetDaxConn[*BarDaxConn](base, "bar")
   619  	assert.NotNil(t, conn)
   620  	assert.True(t, err.IsOk())
   621  
   622  	sabi.Rollback(base)
   623  
   624  	log := Logs.Front()
   625  	assert.Equal(t, log.Value, "FooDaxSrc#SetUp")
   626  	log = log.Next()
   627  	assert.Equal(t, log.Value, "BarDaxSrc#SetUp")
   628  	log = log.Next()
   629  	assert.Equal(t, log.Value, "FooDaxSrc#CreateDaxConn")
   630  	log = log.Next()
   631  	assert.Equal(t, log.Value, "BarDaxSrc#CreateDaxConn")
   632  	log = log.Next()
   633  	if log.Value == "FooDaxConn#Rollback" {
   634  		assert.Equal(t, log.Value, "FooDaxConn#Rollback")
   635  		log = log.Next()
   636  		assert.Equal(t, log.Value, "BarDaxConn#Rollback")
   637  	} else {
   638  		assert.Equal(t, log.Value, "BarDaxConn#Rollback")
   639  		log = log.Next()
   640  		assert.Equal(t, log.Value, "FooDaxConn#Rollback")
   641  	}
   642  	log = log.Next()
   643  	assert.Nil(t, log)
   644  }
   645  
   646  func TestDaxBase_getDaxConn_end(t *testing.T) {
   647  	ClearDaxBase()
   648  	defer ClearDaxBase()
   649  
   650  	base := sabi.NewDaxBase()
   651  
   652  	err := base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   653  	assert.True(t, err.IsOk())
   654  
   655  	err = base.SetUpLocalDaxSrc("bar", BarDaxSrc{})
   656  	assert.True(t, err.IsOk())
   657  
   658  	sabi.Begin(base)
   659  
   660  	var conn sabi.DaxConn
   661  	conn, err = sabi.GetDaxConn[FooDaxConn](base, "foo")
   662  	assert.NotNil(t, conn)
   663  	assert.True(t, err.IsOk())
   664  
   665  	conn, err = sabi.GetDaxConn[*BarDaxConn](base, "bar")
   666  	assert.NotNil(t, conn)
   667  	assert.True(t, err.IsOk())
   668  
   669  	err = sabi.Commit(base)
   670  	assert.True(t, err.IsOk())
   671  
   672  	sabi.End(base)
   673  	assert.True(t, err.IsOk())
   674  
   675  	base.FreeAllLocalDaxSrcs()
   676  
   677  	log := Logs.Front()
   678  	assert.Equal(t, log.Value, "FooDaxSrc#SetUp")
   679  	log = log.Next()
   680  	assert.Equal(t, log.Value, "BarDaxSrc#SetUp")
   681  	log = log.Next()
   682  	assert.Equal(t, log.Value, "FooDaxSrc#CreateDaxConn")
   683  	log = log.Next()
   684  	assert.Equal(t, log.Value, "BarDaxSrc#CreateDaxConn")
   685  	log = log.Next()
   686  	if log.Value == "FooDaxConn#Commit" {
   687  		assert.Equal(t, log.Value, "FooDaxConn#Commit")
   688  		log = log.Next()
   689  		assert.Equal(t, log.Value, "BarDaxConn#Commit")
   690  	} else {
   691  		assert.Equal(t, log.Value, "BarDaxConn#Commit")
   692  		log = log.Next()
   693  		assert.Equal(t, log.Value, "FooDaxConn#Commit")
   694  	}
   695  	log = log.Next()
   696  	if log.Value == "FooDaxConn#Close" {
   697  		assert.Equal(t, log.Value, "FooDaxConn#Close")
   698  		log = log.Next()
   699  		assert.Equal(t, log.Value, "BarDaxConn#Close")
   700  	} else {
   701  		assert.Equal(t, log.Value, "BarDaxConn#Close")
   702  		log = log.Next()
   703  		assert.Equal(t, log.Value, "FooDaxConn#Close")
   704  	}
   705  	log = log.Next()
   706  	if log.Value == "FooDaxSrc#End" {
   707  		assert.Equal(t, log.Value, "FooDaxSrc#End")
   708  		log = log.Next()
   709  		assert.Equal(t, log.Value, "BarDaxSrc#End")
   710  	} else {
   711  		assert.Equal(t, log.Value, "BarDaxSrc#End")
   712  		log = log.Next()
   713  		assert.Equal(t, log.Value, "FooDaxSrc#End")
   714  	}
   715  	log = log.Next()
   716  	assert.Nil(t, log)
   717  }
   718  
   719  func TestDax_runTxn(t *testing.T) {
   720  	ClearDaxBase()
   721  	defer ClearDaxBase()
   722  
   723  	hogeDs := NewMapDaxSrc()
   724  	fugaDs := NewMapDaxSrc()
   725  	piyoDs := NewMapDaxSrc()
   726  
   727  	base := NewHogeFugaPiyoDaxBase()
   728  
   729  	var err sabi.Err
   730  	if err = base.SetUpLocalDaxSrc("hoge", hogeDs); err.IsNotOk() {
   731  		assert.Fail(t, err.Error())
   732  		return
   733  	}
   734  	if err = base.SetUpLocalDaxSrc("fuga", fugaDs); err.IsNotOk() {
   735  		assert.Fail(t, err.Error())
   736  		return
   737  	}
   738  	if err = base.SetUpLocalDaxSrc("piyo", piyoDs); err.IsNotOk() {
   739  		assert.Fail(t, err.Error())
   740  		return
   741  	}
   742  
   743  	hogeDs.dataMap["hogehoge"] = "Hello, world"
   744  
   745  	if err = sabi.RunTxn(base, HogeFugaLogic); err.IsNotOk() {
   746  		assert.Fail(t, err.Error())
   747  		return
   748  	}
   749  	if err = sabi.RunTxn(base, FugaPiyoLogic); err.IsNotOk() {
   750  		assert.Fail(t, err.Error())
   751  		return
   752  	}
   753  
   754  	assert.Equal(t, piyoDs.dataMap["piyopiyo"], "Hello, world")
   755  }
   756  
   757  func TestGetDaxConn_whenDaxConnIsValue(t *testing.T) {
   758  	ClearDaxBase()
   759  	defer ClearDaxBase()
   760  
   761  	base := sabi.NewDaxBase()
   762  	base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   763  	conn, err := sabi.GetDaxConn[FooDaxConn](base, "foo")
   764  	assert.True(t, err.IsOk())
   765  	assert.NotNil(t, conn)
   766  	assert.Equal(t, fmt.Sprintf("%T", conn), "sabi_test.FooDaxConn")
   767  }
   768  
   769  func TestGetDaxConn_whenDaxConnIsValueButError(t *testing.T) {
   770  	ClearDaxBase()
   771  	defer ClearDaxBase()
   772  
   773  	base := sabi.NewDaxBase()
   774  	base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   775  	conn, err := sabi.GetDaxConn[*BarDaxConn](base, "foo")
   776  	assert.True(t, err.IsNotOk())
   777  	assert.Equal(t, err.ReasonName(), "FailToCastDaxConn")
   778  	assert.Equal(t, err.ReasonPackage(), "github.com/sttk/sabi")
   779  	assert.Equal(t, err.Get("Name"), "foo")
   780  	assert.Equal(t, err.Get("FromType"),
   781  		"FooDaxConn (github.com/sttk/sabi_test)")
   782  	assert.Equal(t, err.Get("ToType"),
   783  		"*BarDaxConn (github.com/sttk/sabi_test)")
   784  	assert.Nil(t, conn)
   785  }
   786  
   787  func TestGetDaxConn_whenDaxConnIsValueButPointer(t *testing.T) {
   788  	ClearDaxBase()
   789  	defer ClearDaxBase()
   790  
   791  	base := sabi.NewDaxBase()
   792  	base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   793  	conn, err := sabi.GetDaxConn[*FooDaxConn](base, "foo")
   794  	assert.True(t, err.IsNotOk())
   795  	assert.Equal(t, err.ReasonName(), "FailToCastDaxConn")
   796  	assert.Equal(t, err.ReasonPackage(), "github.com/sttk/sabi")
   797  	assert.Equal(t, err.Get("Name"), "foo")
   798  	assert.Equal(t, err.Get("FromType"),
   799  		"FooDaxConn (github.com/sttk/sabi_test)")
   800  	assert.Equal(t, err.Get("ToType"),
   801  		"*FooDaxConn (github.com/sttk/sabi_test)")
   802  	assert.Nil(t, conn)
   803  }
   804  
   805  func TestGetDaxConn_whenDaxConnIsPointer(t *testing.T) {
   806  	ClearDaxBase()
   807  	defer ClearDaxBase()
   808  
   809  	base := sabi.NewDaxBase()
   810  	base.SetUpLocalDaxSrc("bar", BarDaxSrc{})
   811  	conn, err := sabi.GetDaxConn[*BarDaxConn](base, "bar")
   812  	assert.True(t, err.IsOk())
   813  	assert.NotNil(t, conn)
   814  	assert.Equal(t, fmt.Sprintf("%T", conn), "*sabi_test.BarDaxConn")
   815  }
   816  
   817  func TestGetDaxConn_whenDaxConnIsPointerButError(t *testing.T) {
   818  	ClearDaxBase()
   819  	defer ClearDaxBase()
   820  
   821  	base := sabi.NewDaxBase()
   822  	base.SetUpLocalDaxSrc("bar", BarDaxSrc{})
   823  	conn, err := sabi.GetDaxConn[*FooDaxConn](base, "bar")
   824  	assert.True(t, err.IsNotOk())
   825  	assert.Equal(t, err.ReasonName(), "FailToCastDaxConn")
   826  	assert.Equal(t, err.ReasonPackage(), "github.com/sttk/sabi")
   827  	assert.Equal(t, err.Get("Name"), "bar")
   828  	assert.Equal(t, err.Get("FromType"),
   829  		"*BarDaxConn (github.com/sttk/sabi_test)")
   830  	assert.Equal(t, err.Get("ToType"),
   831  		"*FooDaxConn (github.com/sttk/sabi_test)")
   832  	assert.Nil(t, conn)
   833  }
   834  
   835  /* Raise compile error
   836  func TestGetDaxConn_whenDaxConnIsPointerButValue(t *testing.T) {
   837  	ClearDaxBase()
   838  	defer ClearDaxBase()
   839  
   840  	base := sabi.NewDaxBase()
   841  	base.SetUpLocalDaxSrc("bar", BarDaxSrc{})
   842  	conn, err := sabi.GetDaxConn[BarDaxConn](base, "bar")
   843  	assert.True(t, err.IsNotOk())
   844  	assert.Equal(t, err.ReasonName(), "FailToCastDaxConn")
   845  	assert.Equal(t, err.ReasonPackage(), "github.com/sttk/sabi")
   846  	assert.Equal(t, err.Get("Name"), "bar")
   847  	assert.Equal(t, err.Get("FromType"),
   848  		"*BarDaxConn (github.com/sttk/sabi_test)")
   849  	assert.Equal(t, err.Get("ToType"),
   850  		"BarDaxConn (github.com/sttk/sabi_test)")
   851  	assert.NotNil(t, conn)
   852  }
   853  */
   854  
   855  func TestGetDaxConn_whenDaxConnIsNotFound(t *testing.T) {
   856  	ClearDaxBase()
   857  	defer ClearDaxBase()
   858  
   859  	base := sabi.NewDaxBase()
   860  	conn, err := sabi.GetDaxConn[FooDaxConn](base, "foo")
   861  	assert.True(t, err.IsNotOk())
   862  	assert.Equal(t, err.ReasonName(), "DaxSrcIsNotFound")
   863  	assert.Equal(t, err.ReasonPackage(), "github.com/sttk/sabi")
   864  	assert.Equal(t, err.Get("Name"), "foo")
   865  	assert.NotNil(t, conn)
   866  }
   867  
   868  func TestGetDaxConn_whenDaxConnIsFailedToCreate(t *testing.T) {
   869  	ClearDaxBase()
   870  	defer ClearDaxBase()
   871  
   872  	WillFailToCreateFooDaxConn = true
   873  
   874  	base := sabi.NewDaxBase()
   875  	base.SetUpLocalDaxSrc("foo", FooDaxSrc{})
   876  	conn, err := sabi.GetDaxConn[FooDaxConn](base, "foo")
   877  	assert.True(t, err.IsNotOk())
   878  	assert.Equal(t, err.ReasonName(), "FailToCreateDaxConn")
   879  	assert.Equal(t, err.ReasonPackage(), "github.com/sttk/sabi")
   880  	assert.Equal(t, err.Get("Name"), "foo")
   881  	assert.NotNil(t, conn)
   882  }