func TestClone(t *testing.T) {
m := proto.Clone(cloneTestMessage).(*pb.MyMessage)
if !proto.Equal(m, cloneTestMessage) {
t.Errorf("Clone(%v) = %v", cloneTestMessage, m)
}
// Verify it was a deep copy.
*m.Inner.Port++
if proto.Equal(m, cloneTestMessage) {
t.Error("Mutating clone changed the original")
}
// Byte fields and repeated fields should be copied.
if &m.Pet[0] == &cloneTestMessage.Pet[0] {
t.Error("Pet: repeated field not copied")
}
if &m.Others[0] == &cloneTestMessage.Others[0] {
t.Error("Others: repeated field not copied")
}
if &m.Others[0].Value[0] == &cloneTestMessage.Others[0].Value[0] {
t.Error("Others[0].Value: bytes field not copied")
}
if &m.RepBytes[0] == &cloneTestMessage.RepBytes[0] {
t.Error("RepBytes: repeated field not copied")
}
if &m.RepBytes[0][0] == &cloneTestMessage.RepBytes[0][0] {
t.Error("RepBytes[0]: bytes field not copied")
}
}
// Verify that adding two infos with different hops but same keys
// always chooses the minimum hops.
func TestAddInfoSameKeyDifferentHops(t *testing.T) {
defer leaktest.AfterTest(t)()
stopper := stop.NewStopper()
defer stopper.Stop()
is := newInfoStore(context.TODO(), 1, emptyAddr, stopper)
info1 := is.newInfo(nil, time.Second)
info1.Hops = 1
info2 := is.newInfo(nil, time.Second)
info2.Value.Timestamp.WallTime = info1.Value.Timestamp.WallTime
info2.Hops = 2
if err := is.addInfo("a", info1); err != nil {
t.Errorf("failed insert: %s", err)
}
if err := is.addInfo("a", info2); err == nil {
t.Errorf("shouldn't have inserted info 2: %s", err)
}
i := is.getInfo("a")
if i.Hops != info1.Hops || !proto.Equal(i, info1) {
t.Error("failed to properly combine hops and value", i)
}
// Try yet another info, with lower hops yet (0).
info3 := is.newInfo(nil, time.Second)
if err := is.addInfo("a", info3); err != nil {
t.Error(err)
}
i = is.getInfo("a")
if i.Hops != info3.Hops || !proto.Equal(i, info3) {
t.Error("failed to properly combine hops and value", i)
}
}
// TestSystemTableLiterals compares the result of evaluating the `CREATE TABLE`
// statement strings that describe each system table with the TableDescriptor
// literals that are actually used at runtime. This ensures we can use the hand-
// written literals instead of having to evaluate the `CREATE TABLE` statements
// before initialization and with limited SQL machinery bootstraped, while still
// confident that the result is the same as if `CREATE TABLE` had been run.
//
// This test may also be useful when writing a new system table:
// adding the new schema along with a trivial, empty TableDescriptor literal
// will print the expected proto which can then be used to replace the empty
// one (though pruning the explicit zero values may make it more readable).
func TestSystemTableLiterals(t *testing.T) {
defer leaktest.AfterTest(t)()
type testcase struct {
id sqlbase.ID
schema string
pkg sqlbase.TableDescriptor
}
// test the tables with specific permissions
for _, test := range []testcase{
{keys.NamespaceTableID, sqlbase.NamespaceTableSchema, sqlbase.NamespaceTable},
{keys.DescriptorTableID, sqlbase.DescriptorTableSchema, sqlbase.DescriptorTable},
{keys.UsersTableID, sqlbase.UsersTableSchema, sqlbase.UsersTable},
{keys.ZonesTableID, sqlbase.ZonesTableSchema, sqlbase.ZonesTable},
} {
gen, err := sql.CreateTestTableDescriptor(
keys.SystemDatabaseID,
test.id,
test.schema,
sqlbase.NewPrivilegeDescriptor(security.RootUser, sqlbase.SystemConfigAllowedPrivileges[test.id]),
)
if err != nil {
t.Fatal(err)
}
if !proto.Equal(&test.pkg, &gen) {
t.Fatalf(
"mismatch between re-generated version and pkg version of %s:\npkg:\n\t%#v\ngenerated\n\t%#v",
test.pkg.Name, test.pkg, gen)
}
}
// test the tables with non-specific NewDefaultPrivilegeDescriptor
for _, test := range []testcase{
{keys.LeaseTableID, sqlbase.LeaseTableSchema, sqlbase.LeaseTable},
{keys.EventLogTableID, sqlbase.EventLogTableSchema, sqlbase.EventLogTable},
{keys.RangeEventTableID, sqlbase.RangeEventTableSchema, sqlbase.RangeEventTable},
{keys.UITableID, sqlbase.UITableSchema, sqlbase.UITable},
} {
gen, err := sql.CreateTestTableDescriptor(
keys.SystemDatabaseID, test.id, test.schema, sqlbase.NewDefaultPrivilegeDescriptor(),
)
if err != nil {
t.Fatal(err)
}
if !proto.Equal(&test.pkg, &gen) {
s1 := fmt.Sprintf("%#v", test.pkg)
s2 := fmt.Sprintf("%#v", gen)
for i := range s1 {
if s1[i] != s2[i] {
t.Fatalf(
"mismatch between %s:\npkg:\n\t%#v\npartial-gen\n\t%#v\ngen\n\t%#v",
test.pkg.Name, s1[:i+3], s2[:i+3], gen)
}
}
panic("did not locate mismatch between re-generated version and pkg version")
}
}
}
// TestClientGetAndPutProto verifies gets and puts of protobufs using the
// client's convenience methods.
func TestClientGetAndPutProto(t *testing.T) {
defer leaktest.AfterTest(t)()
s, _, _ := serverutils.StartServer(t, base.TestServerArgs{})
defer s.Stopper().Stop()
db := createTestClient(t, s)
zoneConfig := config.ZoneConfig{
NumReplicas: 2,
Constraints: config.Constraints{Constraints: []config.Constraint{{Value: "mem"}}},
RangeMinBytes: 1 << 10, // 1k
RangeMaxBytes: 1 << 18, // 256k
}
key := roachpb.Key(testUser + "/zone-config")
if err := db.Put(context.TODO(), key, &zoneConfig); err != nil {
t.Fatalf("unable to put proto: %s", err)
}
var readZoneConfig config.ZoneConfig
if err := db.GetProto(context.TODO(), key, &readZoneConfig); err != nil {
t.Fatalf("unable to get proto: %s", err)
}
if !proto.Equal(&zoneConfig, &readZoneConfig) {
t.Errorf("expected %+v, but found %+v", zoneConfig, readZoneConfig)
}
}
// TestClientGetAndPutProto verifies gets and puts of protobufs using the
// client's convenience methods.
func TestClientGetAndPutProto(t *testing.T) {
defer leaktest.AfterTest(t)
s := server.StartTestServer(t)
defer s.Stop()
db := createTestClient(t, s.Stopper(), s.ServingAddr())
zoneConfig := &config.ZoneConfig{
ReplicaAttrs: []roachpb.Attributes{
{Attrs: []string{"dc1", "mem"}},
{Attrs: []string{"dc2", "mem"}},
},
RangeMinBytes: 1 << 10, // 1k
RangeMaxBytes: 1 << 18, // 256k
}
key := roachpb.Key(testUser + "/zone-config")
if pErr := db.Put(key, zoneConfig); pErr != nil {
t.Fatalf("unable to put proto: %s", pErr)
}
readZoneConfig := &config.ZoneConfig{}
if pErr := db.GetProto(key, readZoneConfig); pErr != nil {
t.Fatalf("unable to get proto: %v", pErr)
}
if !proto.Equal(zoneConfig, readZoneConfig) {
t.Errorf("expected %+v, but found %+v", zoneConfig, readZoneConfig)
}
}
// TestClientForwardUnresolved verifies that a client does not resolve a forward
// address prematurely.
func TestClientForwardUnresolved(t *testing.T) {
defer leaktest.AfterTest(t)()
stopper := stop.NewStopper()
defer stopper.Stop()
const nodeID = 1
local := startGossip(nodeID, stopper, t, metric.NewRegistry())
addr := local.GetNodeAddr()
client := newClient(log.AmbientContext{}, addr, makeMetrics()) // never started
newAddr := util.UnresolvedAddr{
NetworkField: "tcp",
AddressField: "localhost:2345",
}
reply := &Response{
NodeID: nodeID,
Addr: *addr,
AlternateNodeID: nodeID + 1,
AlternateAddr: &newAddr,
}
if err := client.handleResponse(
context.TODO(), local, reply,
); !testutils.IsError(err, "received forward") {
t.Fatal(err)
}
if !proto.Equal(client.forwardAddr, &newAddr) {
t.Fatalf("unexpected forward address %v, expected %v", client.forwardAddr, &newAddr)
}
}
func TestRoundTripProto3(t *testing.T) {
m := &pb.Message{
Name: "David", // (2 | 1<<3): 0x0a 0x05 "David"
Hilarity: pb.Message_PUNS, // (0 | 2<<3): 0x10 0x01
HeightInCm: 178, // (0 | 3<<3): 0x18 0xb2 0x01
Data: []byte("roboto"), // (2 | 4<<3): 0x20 0x06 "roboto"
ResultCount: 47, // (0 | 7<<3): 0x38 0x2f
TrueScotsman: true, // (0 | 8<<3): 0x40 0x01
Score: 8.1, // (5 | 9<<3): 0x4d <8.1>
Key: []uint64{1, 0xdeadbeef},
Nested: &pb.Nested{
Bunny: "Monty",
},
}
t.Logf(" m: %v", m)
b, err := proto.Marshal(m)
if err != nil {
t.Fatalf("proto.Marshal: %v", err)
}
t.Logf(" b: %q", b)
m2 := new(pb.Message)
if err := proto.Unmarshal(b, m2); err != nil {
t.Fatalf("proto.Unmarshal: %v", err)
}
t.Logf("m2: %v", m2)
if !proto.Equal(m, m2) {
t.Errorf("proto.Equal returned false:\n m: %v\nm2: %v", m, m2)
}
}
func TestProto3SetDefaults(t *testing.T) {
in := &pb.Message{
Terrain: map[string]*pb.Nested{
"meadow": new(pb.Nested),
},
Proto2Field: new(tpb.SubDefaults),
Proto2Value: map[string]*tpb.SubDefaults{
"badlands": new(tpb.SubDefaults),
},
}
got := proto.Clone(in).(*pb.Message)
proto.SetDefaults(got)
// There are no defaults in proto3. Everything should be the zero value, but
// we need to remember to set defaults for nested proto2 messages.
want := &pb.Message{
Terrain: map[string]*pb.Nested{
"meadow": new(pb.Nested),
},
Proto2Field: &tpb.SubDefaults{N: proto.Int64(7)},
Proto2Value: map[string]*tpb.SubDefaults{
"badlands": {N: proto.Int64(7)},
},
}
if !proto.Equal(got, want) {
t.Errorf("with in = %v\nproto.SetDefaults(in) =>\ngot %v\nwant %v", in, got, want)
}
}
// TestClientForwardUnresolved verifies that a client does not resolve a forward
// address prematurely.
func TestClientForwardUnresolved(t *testing.T) {
defer leaktest.AfterTest(t)()
stopper := stop.NewStopper()
defer stopper.Stop()
const nodeID = 1
local := startGossip(nodeID, stopper, t)
local.mu.Lock()
addr := local.is.NodeAddr
local.mu.Unlock()
client := newClient(&addr) // never started
newAddr := util.UnresolvedAddr{
NetworkField: "tcp",
AddressField: "localhost:2345",
}
reply := &Response{
NodeID: nodeID,
Addr: addr,
AlternateNodeID: nodeID + 1,
AlternateAddr: &newAddr,
}
if err := client.handleResponse(local, reply); !testutils.IsError(err, "received forward") {
t.Fatal(err)
}
if !proto.Equal(client.forwardAddr, &newAddr) {
t.Fatalf("unexpected forward address %v, expected %v", client.forwardAddr, &newAddr)
}
}
// TestKVClientGetAndPutProto verifies gets and puts of protobufs using the
// KV client's convenience methods.
func TestKVClientGetAndPutProto(t *testing.T) {
s := StartTestServer(t)
defer s.Stop()
kvClient := createTestClient(s.HTTPAddr)
kvClient.User = storage.UserRoot
zoneConfig := &proto.ZoneConfig{
ReplicaAttrs: []proto.Attributes{
{Attrs: []string{"dc1", "mem"}},
{Attrs: []string{"dc2", "mem"}},
},
RangeMinBytes: 1 << 10, // 1k
RangeMaxBytes: 1 << 18, // 256k
}
key := proto.Key("zone-config")
if err := kvClient.PutProto(key, zoneConfig); err != nil {
t.Fatalf("unable to put proto: %s", err)
}
readZoneConfig := &proto.ZoneConfig{}
ok, ts, err := kvClient.GetProto(key, readZoneConfig)
if !ok || err != nil {
t.Fatalf("unable to get proto ok? %t: %s", ok, err)
}
if ts.Equal(proto.ZeroTimestamp) {
t.Error("expected non-zero timestamp")
}
if !gogoproto.Equal(zoneConfig, readZoneConfig) {
t.Errorf("expected zone configs equal; %+v != %+v", zoneConfig, readZoneConfig)
}
}
func TestBatchProto(t *testing.T) {
defer leaktest.AfterTest(t)()
stopper := stop.NewStopper()
defer stopper.Stop()
e := NewInMem(roachpb.Attributes{}, 1<<20)
stopper.AddCloser(e)
b := e.NewBatch()
defer b.Close()
val := roachpb.MakeValueFromString("value")
if _, _, err := PutProto(b, mvccKey("proto"), &val); err != nil {
t.Fatal(err)
}
getVal := &roachpb.Value{}
ok, keySize, valSize, err := b.GetProto(mvccKey("proto"), getVal)
if !ok || err != nil {
t.Fatalf("expected GetProto to success ok=%t: %s", ok, err)
}
if keySize != 6 {
t.Errorf("expected key size 6; got %d", keySize)
}
data, err := protoutil.Marshal(&val)
if err != nil {
t.Fatal(err)
}
if valSize != int64(len(data)) {
t.Errorf("expected value size %d; got %d", len(data), valSize)
}
if !proto.Equal(getVal, &val) {
t.Errorf("expected %v; got %v", &val, getVal)
}
// Before commit, proto will not be available via engine.
if ok, _, _, err := e.GetProto(mvccKey("proto"), getVal); ok || err != nil {
t.Fatalf("expected GetProto to fail ok=%t: %s", ok, err)
}
// Commit and verify the proto can be read directly from the engine.
if err := b.Commit(); err != nil {
t.Fatal(err)
}
if ok, _, _, err := e.GetProto(mvccKey("proto"), getVal); !ok || err != nil {
t.Fatalf("expected GetProto to success ok=%t: %s", ok, err)
}
if !proto.Equal(getVal, &val) {
t.Errorf("expected %v; got %v", &val, getVal)
}
}
func TestTimeSeriesToValue(t *testing.T) {
tsOriginal := &InternalTimeSeriesData{
StartTimestampNanos: 1415398729000000000,
SampleDurationNanos: 1000000000,
Samples: []*InternalTimeSeriesSample{
{
Offset: 1,
Count: 1,
Sum: 64,
},
{
Offset: 2,
Count: 1,
Sum: 2,
},
{
Offset: 3,
Count: 1,
Sum: 3,
},
},
}
// Wrap the TSD into a Value
valueOriginal, err := tsOriginal.ToValue()
if err != nil {
t.Fatalf("error marshaling InternalTimeSeriesData: %s", err.Error())
}
if a, e := valueOriginal.GetTag(), ValueType_TIMESERIES; a != e {
t.Errorf("Value did not have expected tag value of %s, had %s", e, a)
}
// Ensure the Value's 'bytes' field contains the marshalled TSD
tsEncoded, err := gogoproto.Marshal(tsOriginal)
if err != nil {
t.Fatalf("error marshaling TimeSeriesData: %s", err.Error())
}
if a, e := valueOriginal.Bytes, tsEncoded; !bytes.Equal(a, e) {
t.Errorf("bytes field was not properly encoded: expected %v, got %v", e, a)
}
// Extract the TSD from the Value
tsNew, err := InternalTimeSeriesDataFromValue(valueOriginal)
if err != nil {
t.Errorf("error extracting Time Series: %s", err.Error())
}
if !gogoproto.Equal(tsOriginal, tsNew) {
t.Errorf("extracted time series not equivalent to original; %v != %v", tsNew, tsOriginal)
}
// Make sure ExtractTimeSeries doesn't work on non-TimeSeries values
valueNotTs := &Value{
Bytes: []byte("testvalue"),
}
if _, err := InternalTimeSeriesDataFromValue(valueNotTs); err == nil {
t.Errorf("did not receive expected error when extracting TimeSeries from regular Byte value.")
}
}
func TestMerge(t *testing.T) {
for _, m := range mergeTests {
got := proto.Clone(m.dst)
proto.Merge(got, m.src)
if !proto.Equal(got, m.want) {
t.Errorf("Merge(%v, %v)\n got %v\nwant %v\n", m.dst, m.src, got, m.want)
}
}
}
func TestUpdateOffsetOnHeartbeat(t *testing.T) {
defer leaktest.AfterTest(t)
stopper := stop.NewStopper()
defer stopper.Stop()
ctx := newNodeTestContext(nil, stopper)
_, ln := newTestServer(t, ctx, false)
// Create a client and set its remote offset. On first heartbeat,
// it will update the server's remote clocks map. We create the
// client manually here to allow us to set the remote offset
// before the first heartbeat.
tlsConfig, err := ctx.GetClientTLSConfig()
if err != nil {
t.Fatal(err)
}
serverAddr := ln.Addr()
client := &Client{
Closed: make(chan struct{}),
addr: util.MakeUnresolvedAddr(serverAddr.Network(), serverAddr.String()),
tlsConfig: tlsConfig,
clock: ctx.localClock,
remoteClocks: ctx.RemoteClocks,
remoteOffset: RemoteOffset{
Offset: 10,
Uncertainty: 5,
MeasuredAt: 20,
},
}
if err = client.connect(); err != nil {
t.Fatal(err)
}
ctx.RemoteClocks.mu.Lock()
remoteAddr := client.RemoteAddr().String()
o := ctx.RemoteClocks.offsets[remoteAddr]
ctx.RemoteClocks.mu.Unlock()
expServerOffset := RemoteOffset{Offset: -10, Uncertainty: 5, MeasuredAt: 20}
if proto.Equal(&o, &expServerOffset) {
t.Errorf("expected updated offset %v, instead %v", expServerOffset, o)
}
ln.Close()
// Remove the offset from RemoteClocks and close the connection from the
// remote end. A new offset for the server should not be added to the clock
// monitor.
ctx.RemoteClocks.mu.Lock()
delete(ctx.RemoteClocks.offsets, remoteAddr)
ln.Close()
ctx.RemoteClocks.mu.Unlock()
ctx.RemoteClocks.mu.Lock()
if offset, ok := ctx.RemoteClocks.offsets[remoteAddr]; ok {
t.Errorf("unexpected updated offset: %v", offset)
}
ctx.RemoteClocks.mu.Unlock()
}
// anyEqual reports whether two messages which may be google.protobuf.Any or may
// contain google.protobuf.Any fields are equal. We can't use proto.Equal for
// comparison, because semantically equivalent messages may be marshaled to
// binary in different tag order. Instead, trust that TextMarshaler with
// ExpandAny option works and compare the text marshaling results.
func anyEqual(got, want proto.Message) bool {
// if messages are proto.Equal, no need to marshal.
if proto.Equal(got, want) {
return true
}
g := expandedMarshaler.Text(got)
w := expandedMarshaler.Text(want)
return g == w
}
func TestDurationProto(t *testing.T) {
for _, test := range durationTests {
if test.isValid && test.inRange {
got := DurationProto(test.dur)
if !proto.Equal(got, test.proto) {
t.Errorf("DurationProto(%v) = %v, want %v", test.dur, got, test.proto)
}
}
}
}
func TestTimestampProto(t *testing.T) {
for _, s := range tests {
got, err := TimestampProto(s.t)
if (err == nil) != s.valid {
t.Errorf("TimestampProto(%v) error = %v, but valid = %t", s.t, err, s.valid)
} else if s.valid && !proto.Equal(got, s.ts) {
t.Errorf("TimestampProto(%v) = %v, want %v", s.t, got, s.ts)
}
}
// No corresponding special case here: no time.Time results in a nil Timestamp.
}
// TestUpdateOffset tests the three cases that UpdateOffset should or should
// not update the offset for an addr.
func TestUpdateOffset(t *testing.T) {
defer leaktest.AfterTest(t)()
monitor := newRemoteClockMonitor(hlc.NewClock(hlc.UnixNano))
// Case 1: There is no prior offset for the address.
var offset1 RemoteOffset
monitor.UpdateOffset("addr", offset1)
if o := monitor.mu.offsets["addr"]; !proto.Equal(&o, &offset1) {
t.Errorf("expected offset %v, instead %v", offset1, o)
}
// Case 2: The old offset for addr was measured before lastMonitoredAt.
monitor.mu.lastMonitoredAt = time.Unix(0, 5)
offset2 := RemoteOffset{
Offset: 0,
Uncertainty: 20,
MeasuredAt: 6,
}
monitor.UpdateOffset("addr", offset2)
if o := monitor.mu.offsets["addr"]; !proto.Equal(&o, &offset2) {
t.Errorf("expected offset %v, instead %v", offset2, o)
}
// Case 3: The new offset's error is smaller.
offset3 := RemoteOffset{
Offset: 0,
Uncertainty: 10,
MeasuredAt: 8,
}
monitor.UpdateOffset("addr", offset3)
if o := monitor.mu.offsets["addr"]; !proto.Equal(&o, &offset3) {
t.Errorf("expected offset %v, instead %v", offset3, o)
}
// Larger error and offset3.MeasuredAt > lastMonitoredAt, so no update.
monitor.UpdateOffset("addr", offset2)
if o := monitor.mu.offsets["addr"]; !proto.Equal(&o, &offset3) {
t.Errorf("expected offset %v, instead %v", offset3, o)
}
}
func TestOffsetMeasurement(t *testing.T) {
defer leaktest.AfterTest(t)
stopper := stop.NewStopper()
defer stopper.Stop()
serverManual := hlc.NewManualClock(10)
serverClock := hlc.NewClock(serverManual.UnixNano)
ctx := newNodeTestContext(serverClock, stopper)
s, ln := newTestServer(t, ctx, true)
heartbeat := &HeartbeatService{
clock: serverClock,
remoteClockMonitor: newRemoteClockMonitor(serverClock),
}
if err := heartbeat.Register(s); err != nil {
t.Fatalf("Unable to register heartbeat service: %s", err)
}
// Create a client that is 10 nanoseconds behind the server.
// Use the server context (heartbeat is node-to-node).
advancing := AdvancingClock{time: 0, advancementInterval: 10}
clientClock := hlc.NewClock(advancing.UnixNano)
context := newNodeTestContext(clientClock, stopper)
c := NewClient(ln.Addr(), context)
<-c.Healthy()
expectedOffset := RemoteOffset{Offset: 5, Uncertainty: 5, MeasuredAt: 10}
if o := c.remoteOffset; !proto.Equal(&o, &expectedOffset) {
t.Errorf("expected offset %v, actual %v", expectedOffset, o)
}
// Ensure the offsets map was updated properly too.
context.RemoteClocks.mu.Lock()
if o := context.RemoteClocks.offsets[c.RemoteAddr().String()]; !proto.Equal(&o, &expectedOffset) {
t.Errorf("expected offset %v, actual %v", expectedOffset, o)
}
context.RemoteClocks.mu.Unlock()
}
func TestUnmarshalDynamic(t *testing.T) {
want := &pb.FileDescriptorProto{Name: proto.String("foo")}
a, err := MarshalAny(want)
if err != nil {
t.Fatal(err)
}
var got DynamicAny
if err := UnmarshalAny(a, &got); err != nil {
t.Fatal(err)
}
if !proto.Equal(got.Message, want) {
t.Errorf("invalid result from UnmarshalAny, got %q want %q", got.Message, want)
}
}
func TestMarshalUnmarshal(t *testing.T) {
orig := &Any{Value: []byte("test")}
packed, err := MarshalAny(orig)
if err != nil {
t.Errorf("MarshalAny(%+v): got: _, %v exp: _, nil", orig, err)
}
unpacked := &Any{}
err = UnmarshalAny(packed, unpacked)
if err != nil || !proto.Equal(unpacked, orig) {
t.Errorf("got: %v, %+v; want nil, %+v", err, unpacked, orig)
}
}
func expectDescriptor(systemConfig config.SystemConfig, idKey roachpb.Key, desc *Descriptor) error {
descValue := systemConfig.GetValue(idKey)
if descValue == nil {
return errStaleMetadata
}
var cachedDesc Descriptor
if err := descValue.GetProto(&cachedDesc); err != nil {
return err
}
if !proto.Equal(&cachedDesc, desc) {
return errStaleMetadata
}
return nil
}
// TestSystemTableLiterals compares the result of evaluating the `CREATE TABLE`
// statement strings that describe each system table with the TableDescriptor
// literals that are actually used at runtime. This ensures we can use the hand-
// written literals instead of having to evaluate the `CREATE TABLE` statements
// before initialization and with limited SQL machinery bootstraped, while still
// confident that the result is the same as if `CREATE TABLE` had been run.
//
// This test may also be useful when writing a new system table:
// adding the new schema along with a trivial, empty TableDescriptor literal
// will print the expected proto which can then be used to replace the empty
// one (though pruning the explicit zero values may make it more readable).
func TestSystemTableLiterals(t *testing.T) {
defer leaktest.AfterTest(t)()
type testcase struct {
id sqlbase.ID
schema string
pkg sqlbase.TableDescriptor
}
// test the tables with specific permissions
for _, test := range []testcase{
{keys.NamespaceTableID, sqlbase.NamespaceTableSchema, sqlbase.NamespaceTable},
{keys.DescriptorTableID, sqlbase.DescriptorTableSchema, sqlbase.DescriptorTable},
{keys.UsersTableID, sqlbase.UsersTableSchema, sqlbase.UsersTable},
{keys.ZonesTableID, sqlbase.ZonesTableSchema, sqlbase.ZonesTable},
} {
gen := sql.CreateTableDescriptor(test.id, keys.SystemDatabaseID, test.schema,
sqlbase.NewPrivilegeDescriptor(security.RootUser, sqlbase.SystemConfigAllowedPrivileges[test.id]))
if !proto.Equal(&test.pkg, &gen) {
t.Fatalf(
"mismatch between re-generated version and pkg version of %s:\npkg:\n\t%#v\ngenerated\n\t%#v",
test.pkg.Name, test.pkg, gen)
}
}
// test the tables with non-specific NewDefaultPrivilegeDescriptor
for _, test := range []testcase{
{keys.LeaseTableID, sqlbase.LeaseTableSchema, sqlbase.LeaseTable},
{keys.UITableID, sqlbase.UITableSchema, sqlbase.UITable},
} {
gen := sql.CreateTableDescriptor(test.id, keys.SystemDatabaseID, test.schema, sqlbase.NewDefaultPrivilegeDescriptor())
if !proto.Equal(&test.pkg, &gen) {
t.Fatalf(
"mismatch between re-generated version and pkg version of %s:\npkg:\n\t%#v\ngenerated\n\t%#v",
test.pkg.Name, test.pkg, gen)
}
}
}
func TestUpdateOffsetOnHeartbeat(t *testing.T) {
defer leaktest.AfterTest(t)()
stopper := stop.NewStopper()
defer stopper.Stop()
ctx := newNodeTestContext(nil, stopper)
_, ln := newTestServer(t, ctx, false)
remoteAddr := ln.Addr().String()
ctx.RemoteClocks.mu.Lock()
ctx.RemoteClocks.mu.offsets[remoteAddr] = RemoteOffset{
Offset: 10,
Uncertainty: 5,
MeasuredAt: 20,
}
ctx.RemoteClocks.mu.Unlock()
// Create a client and set its remote offset. On first heartbeat,
// it will update the server's remote clocks map.
_, err := ctx.GRPCDial(remoteAddr)
if err != nil {
t.Fatal(err)
}
ctx.RemoteClocks.mu.Lock()
o := ctx.RemoteClocks.mu.offsets[remoteAddr]
ctx.RemoteClocks.mu.Unlock()
expServerOffset := RemoteOffset{Offset: -10, Uncertainty: 5, MeasuredAt: 20}
if proto.Equal(&o, &expServerOffset) {
t.Errorf("expected updated offset %v, instead %v", expServerOffset, o)
}
ln.Close()
// Remove the offset from RemoteClocks and close the connection from the
// remote end. A new offset for the server should not be added to the clock
// monitor.
ctx.RemoteClocks.mu.Lock()
delete(ctx.RemoteClocks.mu.offsets, remoteAddr)
ln.Close()
ctx.RemoteClocks.mu.Unlock()
ctx.RemoteClocks.mu.Lock()
if offset, ok := ctx.RemoteClocks.mu.offsets[remoteAddr]; ok {
t.Errorf("unexpected updated offset: %v", offset)
}
ctx.RemoteClocks.mu.Unlock()
}
// assertModelCorrect asserts that the model data being maintained by this
// testModel is equivalent to the actual time series data stored in the
// engine. If the actual data does not match the model, this method will print
// out detailed information about the differences between the two data sets.
func (tm *testModel) assertModelCorrect() {
actualData := tm.getActualData()
if !reflect.DeepEqual(tm.modelData, actualData) {
// Provide a detailed differencing of the actual data and the expected
// model. This is done by comparing individual keys, and printing human
// readable information about any keys which differ in value between the
// two data sets.
var buf bytes.Buffer
buf.WriteString("Found unexpected differences in model data and actual data:\n")
for k, vActual := range actualData {
n, s, r, ts, err := DecodeDataKey([]byte(k))
if err != nil {
tm.t.Fatal(err)
}
if vModel, ok := tm.modelData[k]; !ok {
fmt.Fprintf(&buf, "\nKey %s/%s@%d, r:%d from actual data was not found in model", n, s, ts, r)
} else {
if !proto.Equal(&vActual, &vModel) {
fmt.Fprintf(&buf, "\nKey %s/%s@%d, r:%d differs between model and actual:", n, s, ts, r)
if its, err := vActual.GetTimeseries(); err != nil {
fmt.Fprintf(&buf, "\nActual value is not a valid time series: %v", vActual)
} else {
fmt.Fprintf(&buf, "\nActual value: %s", &its)
}
if its, err := vModel.GetTimeseries(); err != nil {
fmt.Fprintf(&buf, "\nModel value is not a valid time series: %v", vModel)
} else {
fmt.Fprintf(&buf, "\nModel value: %s", &its)
}
}
}
}
// Detect keys in model which were not present in the actual data.
for k := range tm.modelData {
n, s, r, ts, err := DecodeDataKey([]byte(k))
if err != nil {
tm.t.Fatal(err)
}
if _, ok := actualData[k]; !ok {
fmt.Fprintf(&buf, "Key %s/%s@%d, r:%d from model was not found in actual data", n, s, ts, r)
}
}
tm.t.Fatal(buf.String())
}
}
func TestFailedOffsetMeasurement(t *testing.T) {
defer leaktest.AfterTest(t)
stopper := stop.NewStopper()
defer stopper.Stop()
serverManual := hlc.NewManualClock(0)
serverClock := hlc.NewClock(serverManual.UnixNano)
ctx := newNodeTestContext(serverClock, stopper)
s, ln := newTestServer(t, ctx, true)
heartbeat := &ManualHeartbeatService{
clock: serverClock,
remoteClockMonitor: newRemoteClockMonitor(serverClock),
ready: make(chan struct{}),
stopper: stopper,
}
if err := heartbeat.Register(s); err != nil {
t.Fatalf("Unable to register heartbeat service: %s", err)
}
// Create a client that never receives a heartbeat after the first.
clientManual := hlc.NewManualClock(0)
clientClock := hlc.NewClock(clientManual.UnixNano)
context := newNodeTestContext(clientClock, stopper)
context.heartbeatTimeout = 20 * context.heartbeatInterval
c := NewClient(ln.Addr(), context)
heartbeat.ready <- struct{}{} // Allow one heartbeat for initialization.
<-c.Healthy()
// Synchronously wait on missing the next heartbeat.
if err := util.IsTrueWithin(func() bool {
select {
case <-c.Healthy():
return false
default:
return true
}
}, context.heartbeatTimeout*10); err != nil {
t.Fatal(err)
}
if !proto.Equal(&c.remoteOffset, &RemoteOffset{}) {
t.Errorf("expected offset %v, actual %v",
RemoteOffset{}, c.remoteOffset)
}
}
func TestStringEscaping(t *testing.T) {
testCases := []struct {
in *pb.Strings
out string
}{
{
// Test data from C++ test (TextFormatTest.StringEscape).
// Single divergence: we don't escape apostrophes.
&pb.Strings{StringField: proto.String("\"A string with ' characters \n and \r newlines and \t tabs and \001 slashes \\ and multiple spaces")},
"string_field: \"\\\"A string with ' characters \\n and \\r newlines and \\t tabs and \\001 slashes \\\\ and multiple spaces\"\n",
},
{
// Test data from the same C++ test.
&pb.Strings{StringField: proto.String("\350\260\267\346\255\214")},
"string_field: \"\\350\\260\\267\\346\\255\\214\"\n",
},
{
// Some UTF-8.
&pb.Strings{StringField: proto.String("\x00\x01\xff\x81")},
`string_field: "\000\001\377\201"` + "\n",
},
}
for i, tc := range testCases {
var buf bytes.Buffer
if err := proto.MarshalText(&buf, tc.in); err != nil {
t.Errorf("proto.MarsalText: %v", err)
continue
}
s := buf.String()
if s != tc.out {
t.Errorf("#%d: Got:\n%s\nExpected:\n%s\n", i, s, tc.out)
continue
}
// Check round-trip.
pb := new(pb.Strings)
if err := proto.UnmarshalText(s, pb); err != nil {
t.Errorf("#%d: UnmarshalText: %v", i, err)
continue
}
if !proto.Equal(pb, tc.in) {
t.Errorf("#%d: Round-trip failed:\nstart: %v\n end: %v", i, tc.in, pb)
}
}
}
// TestDelayedOffsetMeasurement tests that the client will record a
// zero offset if the heartbeat reply exceeds the
// maximumClockReadingDelay, but not the heartbeat timeout.
func TestDelayedOffsetMeasurement(t *testing.T) {
defer leaktest.AfterTest(t)
stopper := stop.NewStopper()
defer stopper.Stop()
serverManual := hlc.NewManualClock(10)
serverClock := hlc.NewClock(serverManual.UnixNano)
ctx := newNodeTestContext(serverClock, stopper)
s, ln := newTestServer(t, ctx, true)
heartbeat := &HeartbeatService{
clock: serverClock,
remoteClockMonitor: newRemoteClockMonitor(serverClock),
}
if err := heartbeat.Register(s); err != nil {
t.Fatalf("Unable to register heartbeat service: %s", err)
}
// Create a client that receives a heartbeat right after the
// maximumClockReadingDelay.
advancing := AdvancingClock{
time: 0,
advancementInterval: maximumClockReadingDelay.Nanoseconds() + 1,
}
clientClock := hlc.NewClock(advancing.UnixNano)
context := newNodeTestContext(clientClock, stopper)
c := NewClient(ln.Addr(), context)
<-c.Healthy()
// Since the reply took too long, we should have a zero offset, even
// though the client is still healthy because it received a heartbeat
// reply.
if o := c.remoteOffset; !proto.Equal(&o, &RemoteOffset{}) {
t.Errorf("expected offset %v, actual %v", RemoteOffset{}, o)
}
// Ensure the general offsets map was updated properly too.
context.RemoteClocks.mu.Lock()
if o, ok := context.RemoteClocks.offsets[c.RemoteAddr().String()]; ok {
t.Errorf("expected offset to not exist, but found %v", o)
}
context.RemoteClocks.mu.Unlock()
}
func TestGet(t *testing.T) {
defer leaktest.AfterTest(t)
emptyKeys := []roachpb.KeyValue{}
someKeys := []roachpb.KeyValue{
plainKV("a", "vala"),
plainKV("c", "valc"),
plainKV("d", "vald"),
}
aVal := roachpb.MakeValueFromString("vala")
bVal := roachpb.MakeValueFromString("valc")
cVal := roachpb.MakeValueFromString("vald")
testCases := []struct {
values []roachpb.KeyValue
key string
value *roachpb.Value
}{
{emptyKeys, "a", nil},
{emptyKeys, "b", nil},
{emptyKeys, "c", nil},
{emptyKeys, "d", nil},
{emptyKeys, "e", nil},
{someKeys, "", nil},
{someKeys, "b", nil},
{someKeys, "e", nil},
{someKeys, "a0", nil},
{someKeys, "a", &aVal},
{someKeys, "c", &bVal},
{someKeys, "d", &cVal},
}
cfg := config.SystemConfig{}
for tcNum, tc := range testCases {
cfg.Values = tc.values
if val := cfg.GetValue([]byte(tc.key)); !proto.Equal(val, tc.value) {
t.Errorf("#%d: expected=%s, found=%s", tcNum, tc.value, val)
}
}
}
func TestEmpty(t *testing.T) {
want := &pb.FileDescriptorProto{}
a, err := MarshalAny(want)
if err != nil {
t.Fatal(err)
}
got, err := EmptyAny(a)
if err != nil {
t.Fatal(err)
}
if !proto.Equal(got, want) {
t.Errorf("unequal empty message, got %q, want %q", got, want)
}
// that's a valid type_url for a message which shouldn't be linked into this
// test binary. We want an error.
a.TypeUrl = "type.googleapis.com/google.protobuf.FieldMask"
if _, err := EmptyAny(a); err == nil {
t.Errorf("got no error for an attempt to create a message of type %q, which shouldn't be linked in", a.TypeUrl)
}
}