go.mercari.io/datastore@v1.8.2/testsuite/batch.go (about)

     1  package testsuite
     2  
     3  import (
     4  	"context"
     5  	"errors"
     6  	"testing"
     7  
     8  	"go.mercari.io/datastore"
     9  )
    10  
    11  func batchPut(ctx context.Context, t *testing.T, client datastore.Client) {
    12  	defer func() {
    13  		err := client.Close()
    14  		if err != nil {
    15  			t.Fatal(err)
    16  		}
    17  	}()
    18  
    19  	type Data struct {
    20  		Str string
    21  	}
    22  
    23  	cnt := 0
    24  	b := client.Batch()
    25  	{ // 1st entity
    26  		key := client.IncompleteKey("Data", nil)
    27  		b.Put(key, &Data{"Hi!"}, func(key datastore.Key, err error) error {
    28  			if err != nil {
    29  				return err
    30  			}
    31  			t.Logf("#1: %s", key.String())
    32  			cnt++
    33  			return nil
    34  		})
    35  	}
    36  	{ // 2nd entity
    37  		key := client.IncompleteKey("Data", nil)
    38  		b.Put(key, &Data{"Hi!"}, func(key datastore.Key, err error) error {
    39  			if err != nil {
    40  				return err
    41  			}
    42  			t.Logf("#2: %s", key.String())
    43  			cnt++
    44  			return nil
    45  		})
    46  	}
    47  
    48  	err := b.Exec(ctx)
    49  	if err != nil {
    50  		t.Fatal(err)
    51  	}
    52  
    53  	if cnt != 2 {
    54  		t.Errorf("unexpected: %v", cnt)
    55  	}
    56  }
    57  
    58  func batchPutWithCustomErrHandler(ctx context.Context, t *testing.T, client datastore.Client) {
    59  	defer func() {
    60  		err := client.Close()
    61  		if err != nil {
    62  			t.Fatal(err)
    63  		}
    64  	}()
    65  
    66  	type Data struct {
    67  		Str string
    68  	}
    69  
    70  	b := client.Batch()
    71  	testErr := errors.New("test")
    72  	{ // 1st entity
    73  		key := client.IncompleteKey("Data", nil)
    74  		b.Put(key, &Data{"Hi!"}, func(key datastore.Key, err error) error {
    75  			return testErr
    76  		})
    77  	}
    78  	{ // 2nd entity
    79  		key := client.IncompleteKey("Data", nil)
    80  		b.Put(key, &Data{"Hi!"}, nil)
    81  	}
    82  
    83  	err := b.Exec(ctx)
    84  	if err == nil {
    85  		t.Fatal(err)
    86  	}
    87  
    88  	merr, ok := err.(datastore.MultiError)
    89  	if !ok {
    90  		t.Fatalf("unexpected: %v", ok)
    91  	}
    92  	if v := len(merr); v != 1 {
    93  		t.Fatalf("unexpected: %v", ok)
    94  	}
    95  	if v := merr[0]; v != testErr {
    96  		t.Errorf("unexpected: %v", v)
    97  	}
    98  }
    99  
   100  func batchGet(ctx context.Context, t *testing.T, client datastore.Client) {
   101  	defer func() {
   102  		err := client.Close()
   103  		if err != nil {
   104  			t.Fatal(err)
   105  		}
   106  	}()
   107  
   108  	type Data struct {
   109  		Str string
   110  	}
   111  
   112  	key1, err := client.Put(ctx, client.IncompleteKey("Data", nil), &Data{"Data 1"})
   113  	if err != nil {
   114  		t.Fatal(err.Error())
   115  	}
   116  	key2, err := client.Put(ctx, client.IncompleteKey("Data", nil), &Data{"Data 2"})
   117  	if err != nil {
   118  		t.Fatal(err.Error())
   119  	}
   120  
   121  	cnt := 0
   122  	b := client.Batch()
   123  	{ // 1st entity
   124  		dst := &Data{}
   125  		b.Get(key1, dst, func(err error) error {
   126  			if err != nil {
   127  				return err
   128  			}
   129  			t.Logf("#1: %s", dst.Str)
   130  			if v := dst.Str; v != "Data 1" {
   131  				t.Errorf("unexpected: %v", v)
   132  			}
   133  			cnt++
   134  			return nil
   135  		})
   136  	}
   137  	{ // 2nd entity
   138  		dst := &Data{}
   139  		b.Get(key2, dst, func(err error) error {
   140  			if err != nil {
   141  				return err
   142  			}
   143  			t.Logf("#2: %s", dst.Str)
   144  			if v := dst.Str; v != "Data 2" {
   145  				t.Errorf("unexpected: %v", v)
   146  			}
   147  			cnt++
   148  			return nil
   149  		})
   150  	}
   151  
   152  	err = b.Exec(ctx)
   153  	if err != nil {
   154  		t.Fatal(err)
   155  	}
   156  
   157  	if cnt != 2 {
   158  		t.Errorf("unexpected: %v", cnt)
   159  	}
   160  }
   161  
   162  func batchGetWithCustomErrHandler(ctx context.Context, t *testing.T, client datastore.Client) {
   163  	defer func() {
   164  		err := client.Close()
   165  		if err != nil {
   166  			t.Fatal(err)
   167  		}
   168  	}()
   169  
   170  	type Data struct {
   171  		Str string
   172  	}
   173  
   174  	key1, err := client.Put(ctx, client.IncompleteKey("Data", nil), &Data{"Data 1"})
   175  	if err != nil {
   176  		t.Fatal(err.Error())
   177  	}
   178  	key2, err := client.Put(ctx, client.IncompleteKey("Data", nil), &Data{"Data 2"})
   179  	if err != nil {
   180  		t.Fatal(err.Error())
   181  	}
   182  
   183  	b := client.Batch()
   184  	testErr := errors.New("test")
   185  	{ // 1st entity
   186  		dst := &Data{}
   187  		b.Get(key1, dst, func(err error) error {
   188  			return testErr
   189  		})
   190  	}
   191  	{ // 2nd entity
   192  		dst := &Data{}
   193  		b.Get(key2, dst, nil)
   194  	}
   195  
   196  	err = b.Exec(ctx)
   197  	if err == nil {
   198  		t.Fatal(err)
   199  	}
   200  
   201  	merr, ok := err.(datastore.MultiError)
   202  	if !ok {
   203  		t.Fatalf("unexpected: %v", ok)
   204  	}
   205  	if v := len(merr); v != 1 {
   206  		t.Fatalf("unexpected: %v", ok)
   207  	}
   208  	if v := merr[0]; v != testErr {
   209  		t.Errorf("unexpected: %v", v)
   210  	}
   211  }
   212  
   213  func batchDelete(ctx context.Context, t *testing.T, client datastore.Client) {
   214  	defer func() {
   215  		err := client.Close()
   216  		if err != nil {
   217  			t.Fatal(err)
   218  		}
   219  	}()
   220  
   221  	type Data struct {
   222  		Str string
   223  	}
   224  
   225  	key1, err := client.Put(ctx, client.IncompleteKey("Data", nil), &Data{"Data 1"})
   226  	if err != nil {
   227  		t.Fatal(err.Error())
   228  	}
   229  	key2, err := client.Put(ctx, client.IncompleteKey("Data", nil), &Data{"Data 2"})
   230  	if err != nil {
   231  		t.Fatal(err.Error())
   232  	}
   233  
   234  	cnt := 0
   235  	b := client.Batch()
   236  	{ // 1st entity
   237  		b.Delete(key1, func(err error) error {
   238  			if err != nil {
   239  				return err
   240  			}
   241  			t.Logf("#1: %s", key1.String())
   242  			err = client.Get(ctx, key1, &Data{})
   243  			if err != datastore.ErrNoSuchEntity {
   244  				t.Fatal(err)
   245  			}
   246  			cnt++
   247  			return nil
   248  		})
   249  	}
   250  	{ // 2nd entity
   251  		b.Delete(key2, func(err error) error {
   252  			if err != nil {
   253  				return err
   254  			}
   255  			t.Logf("#2: %s", key2.String())
   256  			err = client.Get(ctx, key2, &Data{})
   257  			if err != datastore.ErrNoSuchEntity {
   258  				t.Fatal(err)
   259  			}
   260  			cnt++
   261  			return nil
   262  		})
   263  	}
   264  
   265  	err = b.Exec(ctx)
   266  	if err != nil {
   267  		t.Fatal(err)
   268  	}
   269  
   270  	if cnt != 2 {
   271  		t.Errorf("unexpected: %v", cnt)
   272  	}
   273  }
   274  
   275  func batchDeleteWithCustomErrHandler(ctx context.Context, t *testing.T, client datastore.Client) {
   276  	defer func() {
   277  		err := client.Close()
   278  		if err != nil {
   279  			t.Fatal(err)
   280  		}
   281  	}()
   282  
   283  	type Data struct {
   284  		Str string
   285  	}
   286  
   287  	key1, err := client.Put(ctx, client.IncompleteKey("Data", nil), &Data{"Data 1"})
   288  	if err != nil {
   289  		t.Fatal(err.Error())
   290  	}
   291  	key2, err := client.Put(ctx, client.IncompleteKey("Data", nil), &Data{"Data 2"})
   292  	if err != nil {
   293  		t.Fatal(err.Error())
   294  	}
   295  
   296  	b := client.Batch()
   297  	testErr := errors.New("test")
   298  	{ // 1st entity
   299  		b.Delete(key1, func(err error) error {
   300  			return testErr
   301  		})
   302  	}
   303  	{ // 2nd entity
   304  		b.Delete(key2, nil)
   305  	}
   306  
   307  	err = b.Exec(ctx)
   308  	if err == nil {
   309  		t.Fatal(err)
   310  	}
   311  
   312  	merr, ok := err.(datastore.MultiError)
   313  	if !ok {
   314  		t.Fatalf("unexpected: %v", ok)
   315  	}
   316  	if v := len(merr); v != 1 {
   317  		t.Fatalf("unexpected: %v", ok)
   318  	}
   319  	if v := merr[0]; v != testErr {
   320  		t.Errorf("unexpected: %v", v)
   321  	}
   322  }