go.mercari.io/datastore@v1.8.2/boom/tx_aecompat_test.go (about)

     1  package boom
     2  
     3  import (
     4  	"testing"
     5  
     6  	"go.mercari.io/datastore/internal/testutils"
     7  )
     8  
     9  func TestBoomAECompatTransaction_Put(t *testing.T) {
    10  	ctx, client, cleanUp := testutils.SetupCloudDatastore(t)
    11  	defer cleanUp()
    12  
    13  	type Data struct {
    14  		ID  int64 `datastore:"-" boom:"id"`
    15  		Str string
    16  	}
    17  
    18  	bm := FromClient(ctx, client)
    19  
    20  	txOrig, err := bm.NewTransaction()
    21  	if err != nil {
    22  		t.Fatal(err)
    23  	}
    24  
    25  	tx := ToAECompatibleTransaction(txOrig)
    26  
    27  	key, err := tx.Put(&Data{Str: "Str1"})
    28  	if err != nil {
    29  		t.Fatal(err)
    30  	}
    31  	if v := key.Kind(); v != "Data" {
    32  		t.Errorf("unexpected: %v", v)
    33  	}
    34  	if v := key.ID(); v == 0 {
    35  		t.Errorf("unexpected: %v", v)
    36  	}
    37  }
    38  
    39  func TestBoomAECompatTransaction_PutMulti(t *testing.T) {
    40  	ctx, client, cleanUp := testutils.SetupCloudDatastore(t)
    41  	defer cleanUp()
    42  
    43  	type Data struct {
    44  		ID  int64 `datastore:"-" boom:"id"`
    45  		Str string
    46  	}
    47  
    48  	bm := FromClient(ctx, client)
    49  
    50  	txOrig, err := bm.NewTransaction()
    51  	if err != nil {
    52  		t.Fatal(err)
    53  	}
    54  
    55  	tx := ToAECompatibleTransaction(txOrig)
    56  
    57  	list := make([]*Data, 2)
    58  	list[0] = &Data{Str: "Str1"}
    59  	list[1] = &Data{ID: 2, Str: "Str2"}
    60  
    61  	_, err = tx.PutMulti(list)
    62  	if err != nil {
    63  		t.Fatal(err)
    64  	}
    65  	if v := list[0].ID; v == 0 {
    66  		t.Errorf("unexpected: %v", v)
    67  	}
    68  	if v := list[1].ID; v != 2 {
    69  		t.Errorf("unexpected: %v", v)
    70  	}
    71  }
    72  
    73  func TestBoomAECompatTransaction_Get(t *testing.T) {
    74  	ctx, client, cleanUp := testutils.SetupCloudDatastore(t)
    75  	defer cleanUp()
    76  
    77  	type Data struct {
    78  		ID  int64 `datastore:"-" boom:"id"`
    79  		Str string
    80  	}
    81  
    82  	bm := FromClient(ctx, client)
    83  
    84  	_, err := bm.Put(&Data{ID: 3, Str: "A"})
    85  	if err != nil {
    86  		t.Fatal(err)
    87  	}
    88  
    89  	txOrig, err := bm.NewTransaction()
    90  	if err != nil {
    91  		t.Fatal(err)
    92  	}
    93  
    94  	tx := ToAECompatibleTransaction(txOrig)
    95  
    96  	obj := &Data{ID: 3}
    97  	err = tx.Get(obj)
    98  	if err != nil {
    99  		t.Fatal(err)
   100  	}
   101  	if v := obj.ID; v != 3 {
   102  		t.Errorf("unexpected: %v", v)
   103  	}
   104  }
   105  
   106  func TestBoomAECompatTransaction_GetMulti(t *testing.T) {
   107  	ctx, client, cleanUp := testutils.SetupCloudDatastore(t)
   108  	defer cleanUp()
   109  
   110  	type Data struct {
   111  		ID  int64 `datastore:"-" boom:"id"`
   112  		Str string
   113  	}
   114  
   115  	bm := FromClient(ctx, client)
   116  
   117  	list := make([]*Data, 2)
   118  	list[0] = &Data{ID: 3, Str: "A"}
   119  	list[1] = &Data{ID: 4, Str: "B"}
   120  	_, err := bm.PutMulti(list)
   121  	if err != nil {
   122  		t.Fatal(err)
   123  	}
   124  
   125  	txOrig, err := bm.NewTransaction()
   126  	if err != nil {
   127  		t.Fatal(err)
   128  	}
   129  
   130  	tx := ToAECompatibleTransaction(txOrig)
   131  
   132  	list = make([]*Data, 2)
   133  	list[0] = &Data{ID: 3}
   134  	list[1] = &Data{ID: 4}
   135  	err = tx.GetMulti(list)
   136  	if err != nil {
   137  		t.Fatal(err)
   138  	}
   139  	for _, obj := range list {
   140  		if v := obj.Str; v == "" {
   141  			t.Errorf("unexpected: %v", v)
   142  		}
   143  	}
   144  }
   145  
   146  func TestBoomAECompatTransaction_Delete(t *testing.T) {
   147  	ctx, client, cleanUp := testutils.SetupCloudDatastore(t)
   148  	defer cleanUp()
   149  
   150  	type Data struct {
   151  		ID  int64 `datastore:"-" boom:"id"`
   152  		Str string
   153  	}
   154  
   155  	bm := FromClient(ctx, client)
   156  
   157  	_, err := bm.Put(&Data{ID: 3, Str: "A"})
   158  	if err != nil {
   159  		t.Fatal(err)
   160  	}
   161  
   162  	txOrig, err := bm.NewTransaction()
   163  	if err != nil {
   164  		t.Fatal(err)
   165  	}
   166  
   167  	tx := ToAECompatibleTransaction(txOrig)
   168  
   169  	err = tx.Delete(&Data{ID: 3})
   170  	if err != nil {
   171  		t.Fatal(err)
   172  	}
   173  }
   174  
   175  func TestBoomAECompatTransaction_DeleteMulti(t *testing.T) {
   176  	ctx, client, cleanUp := testutils.SetupCloudDatastore(t)
   177  	defer cleanUp()
   178  
   179  	type Data struct {
   180  		ID  int64 `datastore:"-" boom:"id"`
   181  		Str string
   182  	}
   183  
   184  	bm := FromClient(ctx, client)
   185  
   186  	list := make([]*Data, 2)
   187  	list[0] = &Data{ID: 3, Str: "A"}
   188  	list[1] = &Data{ID: 4, Str: "B"}
   189  	_, err := bm.PutMulti(list)
   190  	if err != nil {
   191  		t.Fatal(err)
   192  	}
   193  
   194  	txOrig, err := bm.NewTransaction()
   195  	if err != nil {
   196  		t.Fatal(err)
   197  	}
   198  
   199  	tx := ToAECompatibleTransaction(txOrig)
   200  
   201  	list = make([]*Data, 2)
   202  	list[0] = &Data{ID: 3}
   203  	list[1] = &Data{ID: 4}
   204  	err = tx.DeleteMulti(list)
   205  	if err != nil {
   206  		t.Fatal(err)
   207  	}
   208  }