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

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