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

     1  package sabi_test
     2  
     3  import (
     4  	"container/list"
     5  
     6  	"github.com/sttk/sabi"
     7  )
     8  
     9  var (
    10  	Logs list.List
    11  
    12  	WillFailToSetUpFooDaxSrc   bool
    13  	WillFailToCommitFooDaxConn bool
    14  	WillFailToCreateFooDaxConn bool
    15  
    16  	WillFailToCreateBDaxConn = false
    17  	WillFailToCommitBDaxConn = false
    18  )
    19  
    20  func ClearDaxBase() {
    21  	sabi.ClearGlobalDaxSrcs()
    22  
    23  	Logs.Init()
    24  
    25  	WillFailToSetUpFooDaxSrc = false
    26  	WillFailToCommitFooDaxConn = false
    27  	WillFailToCreateFooDaxConn = false
    28  
    29  	WillFailToCreateBDaxConn = false
    30  	WillFailToCommitBDaxConn = false
    31  }
    32  
    33  type /* error reasons */ (
    34  	FailToDoSomething struct{ Text string }
    35  
    36  	FailToCreateBDaxConn struct{}
    37  	FailToCommitBDaxConn struct{}
    38  	FailToRunLogic       struct{}
    39  )
    40  
    41  // FooDaxConn
    42  
    43  type FooDaxConn struct {
    44  	Label string
    45  	Map   map[string]string
    46  }
    47  
    48  func (conn FooDaxConn) Commit() sabi.Err {
    49  	if WillFailToCommitFooDaxConn {
    50  		return sabi.NewErr(FailToDoSomething{Text: "FailToCommitFooDaxConn"})
    51  	}
    52  	Logs.PushBack("FooDaxConn#Commit")
    53  	return sabi.Ok()
    54  }
    55  
    56  func (conn FooDaxConn) Rollback() {
    57  	Logs.PushBack("FooDaxConn#Rollback")
    58  }
    59  
    60  func (conn FooDaxConn) Close() {
    61  	Logs.PushBack("FooDaxConn#Close")
    62  }
    63  
    64  // FooDaxSrc
    65  
    66  type FooDaxSrc struct {
    67  	Label string
    68  }
    69  
    70  func (ds FooDaxSrc) CreateDaxConn() (sabi.DaxConn, sabi.Err) {
    71  	if WillFailToCreateFooDaxConn {
    72  		return nil, sabi.NewErr(FailToDoSomething{Text: "FailToCreateFooDaxConn"})
    73  	}
    74  	Logs.PushBack("FooDaxSrc#CreateDaxConn")
    75  	return FooDaxConn{Label: ds.Label, Map: make(map[string]string)}, sabi.Ok()
    76  }
    77  
    78  func (ds FooDaxSrc) SetUp() sabi.Err {
    79  	if WillFailToSetUpFooDaxSrc {
    80  		return sabi.NewErr(FailToDoSomething{Text: "FailToSetUpFooDaxSrc"})
    81  	}
    82  	Logs.PushBack("FooDaxSrc#SetUp")
    83  	return sabi.Ok()
    84  }
    85  
    86  func (ds FooDaxSrc) End() {
    87  	Logs.PushBack("FooDaxSrc#End")
    88  }
    89  
    90  // BarDaxConn
    91  
    92  type BarDaxConn struct {
    93  	Label string
    94  	Map   map[string]string
    95  }
    96  
    97  func (conn *BarDaxConn) Commit() sabi.Err {
    98  	Logs.PushBack("BarDaxConn#Commit")
    99  	return sabi.Ok()
   100  }
   101  
   102  func (conn *BarDaxConn) Rollback() {
   103  	Logs.PushBack("BarDaxConn#Rollback")
   104  }
   105  
   106  func (conn *BarDaxConn) Close() {
   107  	Logs.PushBack("BarDaxConn#Close")
   108  }
   109  
   110  // BarDaxSrc
   111  
   112  type BarDaxSrc struct {
   113  	Label string
   114  }
   115  
   116  func (ds BarDaxSrc) CreateDaxConn() (sabi.DaxConn, sabi.Err) {
   117  	Logs.PushBack("BarDaxSrc#CreateDaxConn")
   118  	return &BarDaxConn{Label: ds.Label, Map: make(map[string]string)}, sabi.Ok()
   119  }
   120  
   121  func (ds BarDaxSrc) SetUp() sabi.Err {
   122  	Logs.PushBack("BarDaxSrc#SetUp")
   123  	return sabi.Ok()
   124  }
   125  
   126  func (ds BarDaxSrc) End() {
   127  	Logs.PushBack("BarDaxSrc#End")
   128  }
   129  
   130  // MapDaxSrc
   131  
   132  type MapDaxSrc struct {
   133  	dataMap map[string]string
   134  }
   135  
   136  func NewMapDaxSrc() MapDaxSrc {
   137  	return MapDaxSrc{dataMap: make(map[string]string)}
   138  }
   139  
   140  func (ds MapDaxSrc) CreateDaxConn() (sabi.DaxConn, sabi.Err) {
   141  	return MapDaxConn{dataMap: ds.dataMap}, sabi.Ok()
   142  }
   143  
   144  func (ds MapDaxSrc) SetUp() sabi.Err {
   145  	return sabi.Ok()
   146  }
   147  
   148  func (ds MapDaxSrc) End() {
   149  }
   150  
   151  // MapDaxConn
   152  
   153  type MapDaxConn struct {
   154  	dataMap map[string]string
   155  }
   156  
   157  func (conn MapDaxConn) Commit() sabi.Err {
   158  	return sabi.Ok()
   159  }
   160  
   161  func (conn MapDaxConn) Rollback() {
   162  }
   163  
   164  func (conn MapDaxConn) Close() {
   165  }
   166  
   167  // HogeFugaDax
   168  
   169  type HogeFugaDax interface {
   170  	GetHogeData() (string, sabi.Err)
   171  	SetFugaData(data string) sabi.Err
   172  }
   173  
   174  // HogeFugaLogic
   175  
   176  func HogeFugaLogic(dax HogeFugaDax) sabi.Err {
   177  	data, err := dax.GetHogeData()
   178  	if err.IsNotOk() {
   179  		return err
   180  	}
   181  	err = dax.SetFugaData(data)
   182  	return err
   183  }
   184  
   185  // FugaPiyoDax
   186  
   187  type FugaPiyoDax interface {
   188  	GetFugaData() (string, sabi.Err)
   189  	SetPiyoData(data string) sabi.Err
   190  }
   191  
   192  // FugaPiyoLogic
   193  
   194  func FugaPiyoLogic(dax FugaPiyoDax) sabi.Err {
   195  	data, err := dax.GetFugaData()
   196  	if err.IsNotOk() {
   197  		return err
   198  	}
   199  	err = dax.SetPiyoData(data)
   200  	return err
   201  }
   202  
   203  // HogeDax
   204  
   205  type HogeDax struct {
   206  	sabi.Dax
   207  }
   208  
   209  func (dax HogeDax) GetHogeData() (string, sabi.Err) {
   210  	conn, err := sabi.GetDaxConn[MapDaxConn](dax, "hoge")
   211  	if err.IsNotOk() {
   212  		return "", err
   213  	}
   214  	data := conn.dataMap["hogehoge"]
   215  	return data, err
   216  }
   217  
   218  func (dax HogeDax) SetHogeData(data string) sabi.Err {
   219  	conn, err := sabi.GetDaxConn[MapDaxConn](dax, "hoge")
   220  	if err.IsNotOk() {
   221  		return err
   222  	}
   223  	conn.dataMap["hogehoge"] = data
   224  	return err
   225  }
   226  
   227  // FugaDax
   228  
   229  type FugaDax struct {
   230  	sabi.Dax
   231  }
   232  
   233  func (dax FugaDax) GetFugaData() (string, sabi.Err) {
   234  	conn, err := sabi.GetDaxConn[MapDaxConn](dax, "fuga")
   235  	if err.IsNotOk() {
   236  		return "", err
   237  	}
   238  	data := conn.dataMap["fugafuga"]
   239  	return data, err
   240  }
   241  
   242  func (dax FugaDax) SetFugaData(data string) sabi.Err {
   243  	conn, err := sabi.GetDaxConn[MapDaxConn](dax, "fuga")
   244  	if err.IsNotOk() {
   245  		return err
   246  	}
   247  	conn.dataMap["fugafuga"] = data
   248  	return err
   249  }
   250  
   251  // PiyoDax
   252  
   253  type PiyoDax struct {
   254  	sabi.Dax
   255  }
   256  
   257  func (dax PiyoDax) GetPiyoData() (string, sabi.Err) {
   258  	conn, err := sabi.GetDaxConn[MapDaxConn](dax, "piyo")
   259  	if err.IsNotOk() {
   260  		return "", err
   261  	}
   262  	data := conn.dataMap["piyopiyo"]
   263  	return data, err
   264  }
   265  
   266  func (dax PiyoDax) SetPiyoData(data string) sabi.Err {
   267  	conn, err := sabi.GetDaxConn[MapDaxConn](dax, "piyo")
   268  	if err.IsNotOk() {
   269  		return err
   270  	}
   271  	conn.dataMap["piyopiyo"] = data
   272  	return err
   273  }
   274  
   275  // HogeFugaPiyoDaxBase
   276  
   277  func NewHogeFugaPiyoDaxBase() sabi.DaxBase {
   278  	base := sabi.NewDaxBase()
   279  	return struct {
   280  		sabi.DaxBase
   281  		HogeDax
   282  		FugaDax
   283  		PiyoDax
   284  	}{
   285  		DaxBase: base,
   286  		HogeDax: HogeDax{Dax: base},
   287  		FugaDax: FugaDax{Dax: base},
   288  		PiyoDax: PiyoDax{Dax: base},
   289  	}
   290  }
   291  
   292  // ADaxSrc
   293  
   294  type ADaxSrc struct {
   295  	AMap map[string]string
   296  }
   297  
   298  func NewADaxSrc() ADaxSrc {
   299  	return ADaxSrc{AMap: make(map[string]string)}
   300  }
   301  
   302  func (ds ADaxSrc) CreateDaxConn() (sabi.DaxConn, sabi.Err) {
   303  	return ADaxConn{AMap: ds.AMap}, sabi.Ok()
   304  }
   305  
   306  func (ds ADaxSrc) SetUp() sabi.Err {
   307  	return sabi.Ok()
   308  }
   309  
   310  func (ds ADaxSrc) End() {
   311  }
   312  
   313  // ADaxConn
   314  
   315  type ADaxConn struct {
   316  	AMap map[string]string
   317  }
   318  
   319  func (conn ADaxConn) Commit() sabi.Err {
   320  	Logs.PushBack("ADaxConn#Commit")
   321  	return sabi.Ok()
   322  }
   323  
   324  func (conn ADaxConn) Rollback() {
   325  	Logs.PushBack("ADaxConn#Rollback")
   326  }
   327  
   328  func (conn ADaxConn) Close() {
   329  	Logs.PushBack("ADaxConn#Close")
   330  }
   331  
   332  // BDaxSrc
   333  
   334  type BDaxSrc struct {
   335  	BMap map[string]string
   336  }
   337  
   338  func NewBDaxSrc() BDaxSrc {
   339  	return BDaxSrc{BMap: make(map[string]string)}
   340  }
   341  
   342  func (ds BDaxSrc) CreateDaxConn() (sabi.DaxConn, sabi.Err) {
   343  	if WillFailToCreateBDaxConn {
   344  		return nil, sabi.NewErr(FailToCreateBDaxConn{})
   345  	}
   346  	return BDaxConn{BMap: ds.BMap}, sabi.Ok()
   347  }
   348  
   349  func (ds BDaxSrc) SetUp() sabi.Err {
   350  	return sabi.Ok()
   351  }
   352  
   353  func (ds BDaxSrc) End() {
   354  }
   355  
   356  // BDaxConn
   357  
   358  type BDaxConn struct {
   359  	BMap map[string]string
   360  }
   361  
   362  func (conn BDaxConn) Commit() sabi.Err {
   363  	if WillFailToCommitBDaxConn {
   364  		return sabi.NewErr(FailToCommitBDaxConn{})
   365  	}
   366  	Logs.PushBack("BDaxConn#Commit")
   367  	return sabi.Ok()
   368  }
   369  
   370  func (conn BDaxConn) Rollback() {
   371  	Logs.PushBack("BDaxConn#Rollback")
   372  }
   373  
   374  func (conn BDaxConn) Close() {
   375  	Logs.PushBack("BDaxConn#Close")
   376  }
   377  
   378  // CDaxSrc
   379  
   380  type CDaxSrc struct {
   381  	CMap map[string]string
   382  }
   383  
   384  func NewCDaxSrc() CDaxSrc {
   385  	return CDaxSrc{CMap: make(map[string]string)}
   386  }
   387  
   388  func (ds CDaxSrc) CreateDaxConn() (sabi.DaxConn, sabi.Err) {
   389  	return CDaxConn{CMap: ds.CMap}, sabi.Ok()
   390  }
   391  
   392  func (ds CDaxSrc) SetUp() sabi.Err {
   393  	return sabi.Ok()
   394  }
   395  
   396  func (ds CDaxSrc) End() {
   397  }
   398  
   399  // CDaxConn
   400  
   401  type CDaxConn struct {
   402  	CMap map[string]string
   403  }
   404  
   405  func (conn CDaxConn) Commit() sabi.Err {
   406  	Logs.PushBack("CDaxConn#Commit")
   407  	return sabi.Ok()
   408  }
   409  
   410  func (conn CDaxConn) Rollback() {
   411  	Logs.PushBack("CDaxConn#Rollback")
   412  }
   413  
   414  func (conn CDaxConn) Close() {
   415  	Logs.PushBack("CDaxConn#Close")
   416  }
   417  
   418  // AGetDax
   419  
   420  type AGetDax struct {
   421  	sabi.Dax
   422  }
   423  
   424  func (dax AGetDax) GetAData() (string, sabi.Err) {
   425  	conn, err := sabi.GetDaxConn[ADaxConn](dax, "aaa")
   426  	if !err.IsOk() {
   427  		return "", err
   428  	}
   429  	data := conn.AMap["a"]
   430  	return data, sabi.Ok()
   431  }
   432  
   433  // BGetSetDax
   434  
   435  type BGetSetDax struct {
   436  	sabi.Dax
   437  }
   438  
   439  func (dax BGetSetDax) GetBData() (string, sabi.Err) {
   440  	conn, err := sabi.GetDaxConn[BDaxConn](dax, "bbb")
   441  	if !err.IsOk() {
   442  		return "", err
   443  	}
   444  	data := conn.BMap["b"]
   445  	return data, sabi.Ok()
   446  }
   447  
   448  func (dax BGetSetDax) SetBData(data string) sabi.Err {
   449  	conn, err := sabi.GetDaxConn[BDaxConn](dax, "bbb")
   450  	if !err.IsOk() {
   451  		return err
   452  	}
   453  	conn.BMap["b"] = data
   454  	return sabi.Ok()
   455  }
   456  
   457  // CSetDax
   458  
   459  type CSetDax struct {
   460  	sabi.Dax
   461  }
   462  
   463  func (dax CSetDax) SetCData(data string) sabi.Err {
   464  	conn, err := sabi.GetDaxConn[CDaxConn](dax, "ccc")
   465  	if !err.IsOk() {
   466  		return err
   467  	}
   468  	conn.CMap["c"] = data
   469  	return sabi.Ok()
   470  }