registrar_test.go

Documentation: github.com/go-kit/kit/sd/etcd

     1  package etcd
     2  
     3  import (
     4  	"bytes"
     5  	"errors"
     6  	"testing"
     7  
     8  	"github.com/go-kit/log"
     9  )
    10  
    11  // testClient is a basic implementation of Client
    12  type testClient struct {
    13  	registerRes error // value returned when Register or Deregister is called
    14  }
    15  
    16  func (tc *testClient) GetEntries(prefix string) ([]string, error) {
    17  	return nil, nil
    18  }
    19  
    20  func (tc *testClient) WatchPrefix(prefix string, ch chan struct{}) {
    21  	return
    22  }
    23  
    24  func (tc *testClient) Register(s Service) error {
    25  	return tc.registerRes
    26  }
    27  
    28  func (tc *testClient) Deregister(s Service) error {
    29  	return tc.registerRes
    30  }
    31  
    32  // default service used to build registrar in our tests
    33  var testService = Service{"testKey", "testValue", nil, nil}
    34  
    35  // NewRegistar should return a registar with a logger using the service key and value
    36  func TestNewRegistar(t *testing.T) {
    37  	c := Client(&testClient{nil})
    38  	buf := &bytes.Buffer{}
    39  	logger := log.NewLogfmtLogger(buf)
    40  	r := NewRegistrar(
    41  		c,
    42  		testService,
    43  		logger,
    44  	)
    45  
    46  	if err := r.logger.Log("msg", "message"); err != nil {
    47  		t.Fatal(err)
    48  	}
    49  	if want, have := "key=testKey value=testValue msg=message\n", buf.String(); want != have {
    50  		t.Errorf("\nwant: %shave: %s", want, have)
    51  	}
    52  }
    53  
    54  // Register log the error returned by the client or log the successful registration action
    55  // table of test cases for method Register
    56  var registerTestTable = []struct {
    57  	registerRes error  // value returned by the client on calls to Register
    58  	log         string // expected log by the registrar
    59  
    60  }{
    61  	// test case: an error is returned by the client
    62  	{errors.New("regError"), "key=testKey value=testValue err=regError\n"},
    63  	// test case: registration successful
    64  	{nil, "key=testKey value=testValue action=register\n"},
    65  }
    66  
    67  func TestRegister(t *testing.T) {
    68  	for _, tc := range registerTestTable {
    69  		c := Client(&testClient{tc.registerRes})
    70  		buf := &bytes.Buffer{}
    71  		logger := log.NewLogfmtLogger(buf)
    72  		r := NewRegistrar(
    73  			c,
    74  			testService,
    75  			logger,
    76  		)
    77  		r.Register()
    78  		if want, have := tc.log, buf.String(); want != have {
    79  			t.Fatalf("want %v, have %v", want, have)
    80  		}
    81  	}
    82  }
    83  
    84  // Deregister log the error returned by the client or log the successful deregistration action
    85  // table of test cases for method Deregister
    86  var deregisterTestTable = []struct {
    87  	deregisterRes error  // value returned by the client on calls to Deregister
    88  	log           string // expected log by the registrar
    89  }{
    90  	// test case: an error is returned by the client
    91  	{errors.New("deregError"), "key=testKey value=testValue err=deregError\n"},
    92  	// test case: deregistration successful
    93  	{nil, "key=testKey value=testValue action=deregister\n"},
    94  }
    95  
    96  func TestDeregister(t *testing.T) {
    97  	for _, tc := range deregisterTestTable {
    98  		c := Client(&testClient{tc.deregisterRes})
    99  		buf := &bytes.Buffer{}
   100  		logger := log.NewLogfmtLogger(buf)
   101  		r := NewRegistrar(
   102  			c,
   103  			testService,
   104  			logger,
   105  		)
   106  		r.Deregister()
   107  		if want, have := tc.log, buf.String(); want != have {
   108  			t.Fatalf("want %v, have %v", want, have)
   109  		}
   110  	}
   111  }
   112
View as plain text