go.etcd.io/etcd@v3.3.27+incompatible/clientv3/naming/grpc_test.go (about)

     1  // Copyright 2016 The etcd Authors
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License");
     4  // you may not use this file except in compliance with the License.
     5  // You may obtain a copy of the License at
     6  //
     7  //     http://www.apache.org/licenses/LICENSE-2.0
     8  //
     9  // Unless required by applicable law or agreed to in writing, software
    10  // distributed under the License is distributed on an "AS IS" BASIS,
    11  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    12  // See the License for the specific language governing permissions and
    13  // limitations under the License.
    14  
    15  package naming
    16  
    17  import (
    18  	"context"
    19  	"encoding/json"
    20  	"reflect"
    21  	"testing"
    22  
    23  	etcd "github.com/coreos/etcd/clientv3"
    24  	"github.com/coreos/etcd/integration"
    25  	"github.com/coreos/etcd/pkg/testutil"
    26  
    27  	"google.golang.org/grpc/naming"
    28  )
    29  
    30  func TestGRPCResolver(t *testing.T) {
    31  	defer testutil.AfterTest(t)
    32  
    33  	clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
    34  	defer clus.Terminate(t)
    35  
    36  	r := GRPCResolver{
    37  		Client: clus.RandClient(),
    38  	}
    39  
    40  	w, err := r.Resolve("foo")
    41  	if err != nil {
    42  		t.Fatal("failed to resolve foo", err)
    43  	}
    44  	defer w.Close()
    45  
    46  	addOp := naming.Update{Op: naming.Add, Addr: "127.0.0.1", Metadata: "metadata"}
    47  	err = r.Update(context.TODO(), "foo", addOp)
    48  	if err != nil {
    49  		t.Fatal("failed to add foo", err)
    50  	}
    51  
    52  	us, err := w.Next()
    53  	if err != nil {
    54  		t.Fatal("failed to get udpate", err)
    55  	}
    56  
    57  	wu := &naming.Update{
    58  		Op:       naming.Add,
    59  		Addr:     "127.0.0.1",
    60  		Metadata: "metadata",
    61  	}
    62  
    63  	if !reflect.DeepEqual(us[0], wu) {
    64  		t.Fatalf("up = %#v, want %#v", us[0], wu)
    65  	}
    66  
    67  	delOp := naming.Update{Op: naming.Delete, Addr: "127.0.0.1"}
    68  	err = r.Update(context.TODO(), "foo", delOp)
    69  	if err != nil {
    70  		t.Fatalf("failed to udpate %v", err)
    71  	}
    72  
    73  	us, err = w.Next()
    74  	if err != nil {
    75  		t.Fatalf("failed to get udpate %v", err)
    76  	}
    77  
    78  	wu = &naming.Update{
    79  		Op:       naming.Delete,
    80  		Addr:     "127.0.0.1",
    81  		Metadata: "metadata",
    82  	}
    83  
    84  	if !reflect.DeepEqual(us[0], wu) {
    85  		t.Fatalf("up = %#v, want %#v", us[0], wu)
    86  	}
    87  }
    88  
    89  // TestGRPCResolverMulti ensures the resolver will initialize
    90  // correctly with multiple hosts and correctly receive multiple
    91  // updates in a single revision.
    92  func TestGRPCResolverMulti(t *testing.T) {
    93  	defer testutil.AfterTest(t)
    94  
    95  	clus := integration.NewClusterV3(t, &integration.ClusterConfig{Size: 1})
    96  	defer clus.Terminate(t)
    97  	c := clus.RandClient()
    98  
    99  	v, verr := json.Marshal(naming.Update{Addr: "127.0.0.1", Metadata: "md"})
   100  	if verr != nil {
   101  		t.Fatal(verr)
   102  	}
   103  	if _, err := c.Put(context.TODO(), "foo/host", string(v)); err != nil {
   104  		t.Fatal(err)
   105  	}
   106  	if _, err := c.Put(context.TODO(), "foo/host2", string(v)); err != nil {
   107  		t.Fatal(err)
   108  	}
   109  
   110  	r := GRPCResolver{c}
   111  
   112  	w, err := r.Resolve("foo")
   113  	if err != nil {
   114  		t.Fatal("failed to resolve foo", err)
   115  	}
   116  	defer w.Close()
   117  
   118  	updates, nerr := w.Next()
   119  	if nerr != nil {
   120  		t.Fatal(nerr)
   121  	}
   122  	if len(updates) != 2 {
   123  		t.Fatalf("expected two updates, got %+v", updates)
   124  	}
   125  
   126  	_, err = c.Txn(context.TODO()).Then(etcd.OpDelete("foo/host"), etcd.OpDelete("foo/host2")).Commit()
   127  	if err != nil {
   128  		t.Fatal(err)
   129  	}
   130  
   131  	updates, nerr = w.Next()
   132  	if nerr != nil {
   133  		t.Fatal(nerr)
   134  	}
   135  	if len(updates) != 2 || (updates[0].Op != naming.Delete && updates[1].Op != naming.Delete) {
   136  		t.Fatalf("expected two updates, got %+v", updates)
   137  	}
   138  }