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) } }