Remove race from query finalization.

service/datastore/query_test.go

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 package datastore
 
 import (
         "math"
         "testing"
 
+        "github.com/luci/luci-go/common/parallel"
         . "github.com/luci/luci-go/common/testing/assertions"
         . "github.com/smartystreets/goconvey/convey"
 )
 
 const (
         MaxUint     = ^uint(0)
         MaxInt      = int(MaxUint >> 1)
         IntIs32Bits = int64(MaxInt) < math.MaxInt64
 )
 
@@ skipping 312 matching lines @@
                                         So(err, ShouldBeNil)
 
                                         fq.original = nil
                                         fq2.original = nil
                                         So(fq, ShouldResemble, fq2)
                                 }
                         })
                 }
         })
 }
+
+func TestQueryConcurrencySafety(t *testing.T) {
+        t.Parallel()
+
+        Convey("query and derivative query finalization is goroutine-safe", t, func() {
+                const rounds = 10
+
+                q := NewQuery("Foo")
+
+                err := parallel.FanOutIn(func(outerC chan<- func() error) {
+
+                        for i := 0; i < rounds; i++ {
+                                outerQ := q.Gt("Field", i)
+
+                                // Finalize the original query.
+                                outerC <- func() error {
+                                        _, err := q.Finalize()
+                                        return err
+                                }
+
+                                // Finalize the derivative query a lot.
+                                outerC <- func() error {
+                                        return parallel.FanOutIn(func(innerC chan<- func() error) {
+                                                for i := 0; i < rounds; i++ {
+                                                        innerC <- func() error {
+                                                                _, err := outerQ.Finalize()
+                                                                return err
+                                                        }
+                                                }
+                                        })
+                                }
+                        }
+                })
+                So(err, ShouldBeNil)
+        })
+}