diff --git a/registry.go b/registry.go
index 11571a1..c762d7b 100644
--- a/registry.go
+++ b/registry.go
@@ -2,12 +2,10 @@ package registry
 
 import (
 	"fmt"
-	"sort"
 	"strings"
 	"sync"
 	"time"
 
-	"github.com/google/uuid"
 	"github.com/micro/go-micro/v3/logger"
 	"github.com/micro/go-micro/v3/registry"
 	"github.com/micro/go-micro/v3/router"
@@ -18,26 +16,17 @@ var (
 	RefreshInterval = time.Second * 120
 	// PruneInterval is how often we prune the routing table
 	PruneInterval = time.Second * 10
-	// AdvertiseEventsTick is time interval in which the router advertises route updates
-	AdvertiseEventsTick = 10 * time.Second
-	// DefaultAdvertTTL is default advertisement TTL
-	DefaultAdvertTTL = 2 * time.Minute
 )
 
 // rtr implements router interface
 type rtr struct {
 	sync.RWMutex
 
-	running   bool
-	table     *table
-	options   router.Options
-	exit      chan bool
-	initChan  chan bool
-	eventChan chan *router.Event
-
-	// advert subscribers
-	sub         sync.RWMutex
-	subscribers map[string]chan *router.Advert
+	running  bool
+	table    *table
+	options  router.Options
+	exit     chan bool
+	initChan chan bool
 }
 
 // NewRouter creates new router and returns it
@@ -52,9 +41,8 @@ func NewRouter(opts ...router.Option) router.Router {
 
 	// construct the router
 	r := &rtr{
-		options:     options,
-		initChan:    make(chan bool),
-		subscribers: make(map[string]chan *router.Advert),
+		options:  options,
+		initChan: make(chan bool),
 	}
 
 	// create the new table, passing the fetchRoute method in as a fallback if
@@ -327,214 +315,6 @@ func (r *rtr) watchRegistry(w registry.Watcher) error {
 	return nil
 }
 
-// watchTable watches routing table entries and either adds or deletes locally registered service to/from network registry
-// It returns error if the locally registered services either fails to be added/deleted to/from network registry.
-func (r *rtr) watchTable(w router.Watcher) error {
-	exit := make(chan bool)
-
-	defer func() {
-		close(exit)
-	}()
-
-	// wait in the background for the router to stop
-	// when the router stops, stop the watcher and exit
-	go func() {
-		defer w.Stop()
-
-		select {
-		case <-r.exit:
-			return
-		case <-exit:
-			return
-		}
-	}()
-
-	for {
-		event, err := w.Next()
-		if err != nil {
-			if err != router.ErrWatcherStopped {
-				return err
-			}
-			break
-		}
-
-		select {
-		case <-r.exit:
-			return nil
-		case r.eventChan <- event:
-			// process event
-		}
-	}
-
-	return nil
-}
-
-// publishAdvert publishes router advert to advert channel
-func (r *rtr) publishAdvert(advType router.AdvertType, events []*router.Event) {
-	a := &router.Advert{
-		Id:        r.options.Id,
-		Type:      advType,
-		TTL:       DefaultAdvertTTL,
-		Timestamp: time.Now(),
-		Events:    events,
-	}
-
-	r.sub.RLock()
-	for _, sub := range r.subscribers {
-		// now send the message
-		select {
-		case sub <- a:
-		case <-r.exit:
-			r.sub.RUnlock()
-			return
-		}
-	}
-	r.sub.RUnlock()
-}
-
-// adverts maintains a map of router adverts
-type adverts map[uint64]*router.Event
-
-// advertiseEvents advertises routing table events
-// It suppresses unhealthy flapping events and advertises healthy events upstream.
-func (r *rtr) advertiseEvents() error {
-	// ticker to periodically scan event for advertising
-	ticker := time.NewTicker(AdvertiseEventsTick)
-	defer ticker.Stop()
-
-	// adverts is a map of advert events
-	adverts := make(adverts)
-
-	// routing table watcher
-	w, err := r.Watch()
-	if err != nil {
-		return err
-	}
-	defer w.Stop()
-
-	go func() {
-		var err error
-
-		for {
-			select {
-			case <-r.exit:
-				return
-			default:
-				if w == nil {
-					// routing table watcher
-					w, err = r.Watch()
-					if err != nil {
-						if logger.V(logger.DebugLevel, logger.DefaultLogger) {
-							logger.Debugf("Error creating watcher: %v", err)
-						}
-						time.Sleep(time.Second)
-						continue
-					}
-				}
-
-				if err := r.watchTable(w); err != nil {
-					if logger.V(logger.DebugLevel, logger.DefaultLogger) {
-						logger.Debugf("Error watching table: %v", err)
-					}
-					time.Sleep(time.Second)
-				}
-
-				if w != nil {
-					// reset
-					w.Stop()
-					w = nil
-				}
-			}
-		}
-	}()
-
-	for {
-		select {
-		case <-ticker.C:
-			// If we're not advertising any events then sip processing them entirely
-			if r.options.Advertise == router.AdvertiseNone {
-				continue
-			}
-
-			var events []*router.Event
-
-			// collect all events which are not flapping
-			for key, event := range adverts {
-				// if we only advertise local routes skip processing anything not link local
-				if r.options.Advertise == router.AdvertiseLocal && event.Route.Link != "local" {
-					continue
-				}
-
-				// copy the event and append
-				e := new(router.Event)
-				// this is ok, because router.Event only contains builtin types
-				// and no references so this creates a deep copy of struct Event
-				*e = *event
-				events = append(events, e)
-				// delete the advert from adverts
-				delete(adverts, key)
-			}
-
-			// advertise events to subscribers
-			if len(events) > 0 {
-				if logger.V(logger.DebugLevel, logger.DefaultLogger) {
-					logger.Debugf("Router publishing %d events", len(events))
-				}
-				go r.publishAdvert(router.RouteUpdate, events)
-			}
-		case e := <-r.eventChan:
-			// if event is nil, continue
-			if e == nil {
-				continue
-			}
-
-			// If we're not advertising any events then skip processing them entirely
-			if r.options.Advertise == router.AdvertiseNone {
-				continue
-			}
-
-			// if we only advertise local routes skip processing anything not link local
-			if r.options.Advertise == router.AdvertiseLocal && e.Route.Link != "local" {
-				continue
-			}
-
-			if logger.V(logger.DebugLevel, logger.DefaultLogger) {
-				logger.Debugf("Router processing table event %s for service %s %s", e.Type, e.Route.Service, e.Route.Address)
-			}
-
-			// check if we have already registered the route
-			hash := e.Route.Hash()
-			ev, ok := adverts[hash]
-			if !ok {
-				ev = e
-				adverts[hash] = e
-				continue
-			}
-
-			// override the route event only if the previous event was different
-			if ev.Type != e.Type {
-				ev = e
-			}
-		case <-r.exit:
-			if w != nil {
-				w.Stop()
-			}
-			return nil
-		}
-	}
-}
-
-// drain all the events, only called on Stop
-func (r *rtr) drain() {
-	for {
-		select {
-		case <-r.eventChan:
-		default:
-			return
-		}
-	}
-}
-
 // start the router. Should be called under lock.
 func (r *rtr) start() error {
 	if r.running {
@@ -621,130 +401,6 @@ func (r *rtr) start() error {
 	return nil
 }
 
-// Advertise stars advertising the routes to the network and returns the advertisements channel to consume from.
-// If the router is already advertising it returns the channel to consume from.
-// It returns error if either the router is not running or if the routing table fails to list the routes to advertise.
-func (r *rtr) Advertise() (<-chan *router.Advert, error) {
-	r.Lock()
-	defer r.Unlock()
-
-	// we're mutating the subscribers so they need to be locked also
-	r.sub.Lock()
-	defer r.sub.Unlock()
-
-	// already advertising
-	if r.eventChan != nil {
-		advertChan := make(chan *router.Advert, 128)
-		r.subscribers[uuid.New().String()] = advertChan
-		return advertChan, nil
-	}
-
-	// list all the routes and pack them into even slice to advertise
-	events, err := r.flushRouteEvents(router.Create)
-	if err != nil {
-		return nil, fmt.Errorf("failed to flush routes: %s", err)
-	}
-
-	// create event channels
-	r.eventChan = make(chan *router.Event)
-
-	// create advert channel
-	advertChan := make(chan *router.Advert, 128)
-	r.subscribers[uuid.New().String()] = advertChan
-
-	// advertise your presence
-	go r.publishAdvert(router.Announce, events)
-
-	go func() {
-		select {
-		case <-r.exit:
-			return
-		default:
-			if err := r.advertiseEvents(); err != nil {
-				if logger.V(logger.DebugLevel, logger.DefaultLogger) {
-					logger.Debugf("Error adveritising events: %v", err)
-				}
-			}
-		}
-	}()
-
-	return advertChan, nil
-
-}
-
-// Process updates the routing table using the advertised values
-func (r *rtr) Process(a *router.Advert) error {
-	// NOTE: event sorting might not be necessary
-	// copy update events intp new slices
-	events := make([]*router.Event, len(a.Events))
-	copy(events, a.Events)
-	// sort events by timestamp
-	sort.Slice(events, func(i, j int) bool {
-		return events[i].Timestamp.Before(events[j].Timestamp)
-	})
-
-	if logger.V(logger.TraceLevel, logger.DefaultLogger) {
-		logger.Tracef("Router %s processing advert from: %s", r.options.Id, a.Id)
-	}
-
-	for _, event := range events {
-		// skip if the router is the origin of this route
-		if event.Route.Router == r.options.Id {
-			if logger.V(logger.TraceLevel, logger.DefaultLogger) {
-				logger.Tracef("Router skipping processing its own route: %s", r.options.Id)
-			}
-			continue
-		}
-		// create a copy of the route
-		route := event.Route
-		action := event.Type
-
-		if logger.V(logger.TraceLevel, logger.DefaultLogger) {
-			logger.Tracef("Router %s applying %s from router %s for service %s %s", r.options.Id, action, route.Router, route.Service, route.Address)
-		}
-
-		if err := r.manageRoute(route, action.String()); err != nil {
-			return fmt.Errorf("failed applying action %s to routing table: %s", action, err)
-		}
-	}
-
-	return nil
-}
-
-// flushRouteEvents returns a slice of events, one per each route in the routing table
-func (r *rtr) flushRouteEvents(evType router.EventType) ([]*router.Event, error) {
-	// get a list of routes for each service in our routing table
-	// for the configured advertising strategy
-	q := []router.QueryOption{
-		router.QueryStrategy(r.options.Advertise),
-	}
-
-	routes, err := r.table.Query(q...)
-	if err != nil && err != router.ErrRouteNotFound {
-		return nil, err
-	}
-
-	if logger.V(logger.DebugLevel, logger.DefaultLogger) {
-		logger.Debugf("Router advertising %d routes with strategy %s", len(routes), r.options.Advertise)
-	}
-
-	// build a list of events to advertise
-	events := make([]*router.Event, len(routes))
-	var i int
-
-	for _, route := range routes {
-		event := &router.Event{
-			Type:      evType,
-			Timestamp: time.Now(),
-			Route:     route,
-		}
-		events[i] = event
-		i++
-	}
-
-	return events, nil
-}
-
 // Lookup routes in the routing table
 func (r *rtr) Lookup(q ...router.QueryOption) ([]router.Route, error) {
 	return r.Table().Query(q...)
@@ -769,24 +425,6 @@ func (r *rtr) Close() error {
 		}
 		close(r.exit)
 
-		// extract the events
-		r.drain()
-
-		r.sub.Lock()
-		// close advert subscribers
-		for id, sub := range r.subscribers {
-			// close the channel
-			close(sub)
-			// delete the subscriber
-			delete(r.subscribers, id)
-		}
-		r.sub.Unlock()
-	}
-
-	// close and remove event chan
-	if r.eventChan != nil {
-		close(r.eventChan)
-		r.eventChan = nil
 	}
 
 	r.running = false
diff --git a/registry_test.go b/registry_test.go
index 0c1af95..b8886df 100644
--- a/registry_test.go
+++ b/registry_test.go
@@ -1,11 +1,8 @@
 package registry
 
 import (
-	"fmt"
 	"os"
-	"sync"
 	"testing"
-	"time"
 
 	"github.com/micro/go-micro/v3/registry/memory"
 	"github.com/micro/go-micro/v3/router"
@@ -19,11 +16,6 @@ func routerTestSetup() router.Router {
 func TestRouterClose(t *testing.T) {
 	r := routerTestSetup()
 
-	_, err := r.Advertise()
-	if err != nil {
-		t.Errorf("failed to start advertising: %v", err)
-	}
-
 	if err := r.Close(); err != nil {
 		t.Errorf("failed to stop router: %v", err)
 	}
@@ -31,103 +23,3 @@ func TestRouterClose(t *testing.T) {
 		t.Logf("TestRouterStartStop STOPPED")
 	}
 }
-
-func TestRouterAdvertise(t *testing.T) {
-	r := routerTestSetup()
-
-	// lower the advertise interval
-	AdvertiseEventsTick = 500 * time.Millisecond
-
-	ch, err := r.Advertise()
-	if err != nil {
-		t.Errorf("failed to start advertising: %v", err)
-	}
-
-	// receive announce event
-	ann := <-ch
-	if len(os.Getenv("IN_TRAVIS_CI")) == 0 {
-		t.Logf("received announce advert: %v", ann)
-	}
-
-	// Generate random unique routes
-	nrRoutes := 5
-	routes := make([]router.Route, nrRoutes)
-	route := router.Route{
-		Service: "dest.svc",
-		Address: "dest.addr",
-		Gateway: "dest.gw",
-		Network: "dest.network",
-		Router:  "src.router",
-		Link:    "local",
-		Metric:  10,
-	}
-
-	for i := 0; i < nrRoutes; i++ {
-		testRoute := route
-		testRoute.Service = fmt.Sprintf("%s-%d", route.Service, i)
-		routes[i] = testRoute
-	}
-
-	var advertErr error
-
-	createDone := make(chan bool)
-	errChan := make(chan error)
-
-	var wg sync.WaitGroup
-	wg.Add(1)
-	go func() {
-		wg.Done()
-		defer close(createDone)
-		for _, route := range routes {
-			if len(os.Getenv("IN_TRAVIS_CI")) == 0 {
-				t.Logf("Creating route %v", route)
-			}
-			if err := r.Table().Create(route); err != nil {
-				if len(os.Getenv("IN_TRAVIS_CI")) == 0 {
-					t.Logf("Failed to create route: %v", err)
-				}
-				errChan <- err
-				return
-			}
-		}
-	}()
-
-	var adverts int
-	readDone := make(chan bool)
-
-	wg.Add(1)
-	go func() {
-		defer func() {
-			wg.Done()
-			readDone <- true
-		}()
-		for advert := range ch {
-			select {
-			case advertErr = <-errChan:
-				t.Errorf("failed advertising events: %v", advertErr)
-			default:
-				// do nothing for now
-				if len(os.Getenv("IN_TRAVIS_CI")) == 0 {
-					t.Logf("Router advert received: %v", advert)
-				}
-				adverts += len(advert.Events)
-			}
-			return
-		}
-	}()
-
-	// done adding routes to routing table
-	<-createDone
-	// done reading adverts from the routing table
-	<-readDone
-
-	if adverts != nrRoutes {
-		t.Errorf("Expected %d adverts, received: %d", nrRoutes, adverts)
-	}
-
-	wg.Wait()
-
-	if err := r.Close(); err != nil {
-		t.Errorf("failed to stop router: %v", err)
-	}
-}
diff --git a/table.go b/table.go
index 7e4b069..cefd723 100644
--- a/table.go
+++ b/table.go
@@ -217,7 +217,7 @@ func (t *table) List() ([]router.Route, error) {
 }
 
 // isMatch checks if the route matches given query options
-func isMatch(route router.Route, address, gateway, network, rtr string, strategy router.Strategy) bool {
+func isMatch(route router.Route, address, gateway, network, rtr, link string) bool {
 	// matches the values provided
 	match := func(a, b string) bool {
 		if a == "*" || b == "*" || a == b {
@@ -232,13 +232,6 @@ func isMatch(route router.Route, address, gateway, network, rtr string, strategy
 		b string
 	}
 
-	// by default assume we are querying all routes
-	link := "*"
-	// if AdvertiseLocal change the link query accordingly
-	if strategy == router.AdvertiseLocal {
-		link = "local"
-	}
-
 	// compare the following values
 	values := []compare{
 		{gateway, route.Gateway},
@@ -264,7 +257,7 @@ func filterRoutes(routes map[uint64]*route, opts router.QueryOptions) []router.R
 	gateway := opts.Gateway
 	network := opts.Network
 	rtr := opts.Router
-	strategy := opts.Strategy
+	link := opts.Link
 
 	// routeMap stores the routes we're going to advertise
 	routeMap := make(map[string][]router.Route)
@@ -273,37 +266,15 @@ func filterRoutes(routes map[uint64]*route, opts router.QueryOptions) []router.R
 		// get the actual route
 		route := rt.route
 
-		if isMatch(route, address, gateway, network, rtr, strategy) {
+		if isMatch(route, address, gateway, network, rtr, link) {
 			// add matchihg route to the routeMap
 			routeKey := route.Service + "@" + route.Network
-			// append the first found route to routeMap
-			_, ok := routeMap[routeKey]
-			if !ok {
-				routeMap[routeKey] = append(routeMap[routeKey], route)
-				continue
-			}
-
-			// if AdvertiseAll, keep appending
-			if strategy == router.AdvertiseAll || strategy == router.AdvertiseLocal {
-				routeMap[routeKey] = append(routeMap[routeKey], route)
-				continue
-			}
-
-			// now we're going to find the best routes
-			if strategy == router.AdvertiseBest {
-				// if the current optimal route metric is higher than routing table route, replace it
-				if len(routeMap[routeKey]) > 0 {
-					// NOTE: we know that when AdvertiseBest is set, we only ever have one item in current
-					if routeMap[routeKey][0].Metric > route.Metric {
-						routeMap[routeKey][0] = route
-						continue
-					}
-				}
-			}
+			routeMap[routeKey] = append(routeMap[routeKey], route)
 		}
 	}
 
 	var results []router.Route
+
 	for _, route := range routeMap {
 		results = append(results, route...)
 	}
@@ -319,11 +290,6 @@ func (t *table) Query(q ...router.QueryOption) ([]router.Route, error) {
 	// create a cwslicelist of query results
 	results := make([]router.Route, 0, len(t.routes))
 
-	// if No routes are queried, return early
-	if opts.Strategy == router.AdvertiseNone {
-		return results, nil
-	}
-
 	// readAndFilter routes for this service under read lock.
 	readAndFilter := func(q router.QueryOptions) ([]router.Route, bool) {
 		t.RLock()
diff --git a/table_test.go b/table_test.go
index 4fa4131..1cb5fc5 100644
--- a/table_test.go
+++ b/table_test.go
@@ -28,19 +28,19 @@ func TestCreate(t *testing.T) {
 	table, route := testSetup()
 
 	if err := table.Create(route); err != nil {
-		t.Errorf("error adding route: %s", err)
+		t.Fatalf("error adding route: %s", err)
 	}
 
 	// adds new route for the original destination
 	route.Gateway = "dest.gw2"
 
 	if err := table.Create(route); err != nil {
-		t.Errorf("error adding route: %s", err)
+		t.Fatalf("error adding route: %s", err)
 	}
 
 	// adding the same route under Insert policy must error
 	if err := table.Create(route); err != router.ErrDuplicateRoute {
-		t.Errorf("error adding route. Expected error: %s, found: %s", router.ErrDuplicateRoute, err)
+		t.Fatalf("error adding route. Expected error: %s, found: %s", router.ErrDuplicateRoute, err)
 	}
 }
 
@@ -48,7 +48,7 @@ func TestDelete(t *testing.T) {
 	table, route := testSetup()
 
 	if err := table.Create(route); err != nil {
-		t.Errorf("error adding route: %s", err)
+		t.Fatalf("error adding route: %s", err)
 	}
 
 	// should fail to delete non-existant route
@@ -56,14 +56,14 @@ func TestDelete(t *testing.T) {
 	route.Service = "randDest"
 
 	if err := table.Delete(route); err != router.ErrRouteNotFound {
-		t.Errorf("error deleting route. Expected: %s, found: %s", router.ErrRouteNotFound, err)
+		t.Fatalf("error deleting route. Expected: %s, found: %s", router.ErrRouteNotFound, err)
 	}
 
 	// we should be able to delete the existing route
 	route.Service = prevSvc
 
 	if err := table.Delete(route); err != nil {
-		t.Errorf("error deleting route: %s", err)
+		t.Fatalf("error deleting route: %s", err)
 	}
 }
 
@@ -71,21 +71,21 @@ func TestUpdate(t *testing.T) {
 	table, route := testSetup()
 
 	if err := table.Create(route); err != nil {
-		t.Errorf("error adding route: %s", err)
+		t.Fatalf("error adding route: %s", err)
 	}
 
 	// change the metric of the original route
 	route.Metric = 200
 
 	if err := table.Update(route); err != nil {
-		t.Errorf("error updating route: %s", err)
+		t.Fatalf("error updating route: %s", err)
 	}
 
 	// this should add a new route
 	route.Service = "rand.dest"
 
 	if err := table.Update(route); err != nil {
-		t.Errorf("error updating route: %s", err)
+		t.Fatalf("error updating route: %s", err)
 	}
 }
 
@@ -97,17 +97,17 @@ func TestList(t *testing.T) {
 	for i := 0; i < len(svc); i++ {
 		route.Service = svc[i]
 		if err := table.Create(route); err != nil {
-			t.Errorf("error adding route: %s", err)
+			t.Fatalf("error adding route: %s", err)
 		}
 	}
 
 	routes, err := table.List()
 	if err != nil {
-		t.Errorf("error listing routes: %s", err)
+		t.Fatalf("error listing routes: %s", err)
 	}
 
 	if len(routes) != len(svc) {
-		t.Errorf("incorrect number of routes listed. Expected: %d, found: %d", len(svc), len(routes))
+		t.Fatalf("incorrect number of routes listed. Expected: %d, found: %d", len(svc), len(routes))
 	}
 }
 
@@ -124,17 +124,19 @@ func TestQuery(t *testing.T) {
 		route.Network = net[i]
 		route.Gateway = gw[i]
 		route.Router = rtr[i]
+		route.Link = router.DefaultLink
+
 		if err := table.Create(route); err != nil {
-			t.Errorf("error adding route: %s", err)
+			t.Fatalf("error adding route: %s", err)
 		}
 	}
 
 	// return all routes
 	routes, err := table.Query()
 	if err != nil {
-		t.Errorf("error looking up routes: %s", err)
+		t.Fatalf("error looking up routes: %s", err)
 	} else if len(routes) == 0 {
-		t.Errorf("error looking up routes: not found")
+		t.Fatalf("error looking up routes: not found")
 	}
 
 	// query routes particular network
@@ -142,16 +144,16 @@ func TestQuery(t *testing.T) {
 
 	routes, err = table.Query(router.QueryNetwork(network))
 	if err != nil {
-		t.Errorf("error looking up routes: %s", err)
+		t.Fatalf("error looking up routes: %s", err)
 	}
 
 	if len(routes) != 2 {
-		t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 2, len(routes))
+		t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 2, len(routes))
 	}
 
 	for _, route := range routes {
 		if route.Network != network {
-			t.Errorf("incorrect route returned. Expected network: %s, found: %s", network, route.Network)
+			t.Fatalf("incorrect route returned. Expected network: %s, found: %s", network, route.Network)
 		}
 	}
 
@@ -160,15 +162,15 @@ func TestQuery(t *testing.T) {
 
 	routes, err = table.Query(router.QueryGateway(gateway))
 	if err != nil {
-		t.Errorf("error looking up routes: %s", err)
+		t.Fatalf("error looking up routes: %s", err)
 	}
 
 	if len(routes) != 1 {
-		t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes))
+		t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes))
 	}
 
 	if routes[0].Gateway != gateway {
-		t.Errorf("incorrect route returned. Expected gateway: %s, found: %s", gateway, routes[0].Gateway)
+		t.Fatalf("incorrect route returned. Expected gateway: %s, found: %s", gateway, routes[0].Gateway)
 	}
 
 	// query routes for particular router
@@ -176,15 +178,15 @@ func TestQuery(t *testing.T) {
 
 	routes, err = table.Query(router.QueryRouter(rt))
 	if err != nil {
-		t.Errorf("error looking up routes: %s", err)
+		t.Fatalf("error looking up routes: %s", err)
 	}
 
 	if len(routes) != 1 {
-		t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes))
+		t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes))
 	}
 
 	if routes[0].Router != rt {
-		t.Errorf("incorrect route returned. Expected router: %s, found: %s", rt, routes[0].Router)
+		t.Fatalf("incorrect route returned. Expected router: %s, found: %s", rt, routes[0].Router)
 	}
 
 	// query particular gateway and network
@@ -196,57 +198,57 @@ func TestQuery(t *testing.T) {
 
 	routes, err = table.Query(query...)
 	if err != nil {
-		t.Errorf("error looking up routes: %s", err)
+		t.Fatalf("error looking up routes: %s", err)
 	}
 
 	if len(routes) != 1 {
-		t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes))
+		t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes))
 	}
 
 	if routes[0].Gateway != gateway {
-		t.Errorf("incorrect route returned. Expected gateway: %s, found: %s", gateway, routes[0].Gateway)
+		t.Fatalf("incorrect route returned. Expected gateway: %s, found: %s", gateway, routes[0].Gateway)
 	}
 
 	if routes[0].Network != network {
-		t.Errorf("incorrect network returned. Expected network: %s, found: %s", network, routes[0].Network)
+		t.Fatalf("incorrect network returned. Expected network: %s, found: %s", network, routes[0].Network)
 	}
 
 	if routes[0].Router != rt {
-		t.Errorf("incorrect route returned. Expected router: %s, found: %s", rt, routes[0].Router)
+		t.Fatalf("incorrect route returned. Expected router: %s, found: %s", rt, routes[0].Router)
 	}
 
 	// non-existen route query
 	routes, err = table.Query(router.QueryService("foobar"))
 	if err != router.ErrRouteNotFound {
-		t.Errorf("error looking up routes. Expected: %s, found: %s", router.ErrRouteNotFound, err)
+		t.Fatalf("error looking up routes. Expected: %s, found: %s", router.ErrRouteNotFound, err)
 	}
 
 	if len(routes) != 0 {
-		t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 0, len(routes))
+		t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 0, len(routes))
 	}
 
 	// query NO routes
 	query = []router.QueryOption{
 		router.QueryGateway(gateway),
 		router.QueryNetwork(network),
-		router.QueryStrategy(router.AdvertiseNone),
+		router.QueryLink("network"),
 	}
 
 	routes, err = table.Query(query...)
 	if err != nil {
-		t.Errorf("error looking up routes: %s", err)
+		t.Fatalf("error looking up routes: %s", err)
 	}
 
 	if len(routes) > 0 {
-		t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 0, len(routes))
+		t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 0, len(routes))
 	}
 
 	// insert local routes to query
 	for i := 0; i < 2; i++ {
-		route.Link = "local"
+		route.Link = "foobar"
 		route.Address = fmt.Sprintf("local.route.address-%d", i)
 		if err := table.Create(route); err != nil {
-			t.Errorf("error adding route: %s", err)
+			t.Fatalf("error adding route: %s", err)
 		}
 	}
 
@@ -254,16 +256,16 @@ func TestQuery(t *testing.T) {
 	query = []router.QueryOption{
 		router.QueryGateway("*"),
 		router.QueryNetwork("*"),
-		router.QueryStrategy(router.AdvertiseLocal),
+		router.QueryLink("foobar"),
 	}
 
 	routes, err = table.Query(query...)
 	if err != nil {
-		t.Errorf("error looking up routes: %s", err)
+		t.Fatalf("error looking up routes: %s", err)
 	}
 
 	if len(routes) != 2 {
-		t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 2, len(routes))
+		t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 2, len(routes))
 	}
 
 	// add two different routes for svcX with different metric
@@ -271,32 +273,30 @@ func TestQuery(t *testing.T) {
 		route.Service = "svcX"
 		route.Address = fmt.Sprintf("svcX.route.address-%d", i)
 		route.Metric = int64(100 + i)
+		route.Link = router.DefaultLink
 		if err := table.Create(route); err != nil {
-			t.Errorf("error adding route: %s", err)
+			t.Fatalf("error adding route: %s", err)
 		}
 	}
 
-	// query best routes for svcX
 	query = []router.QueryOption{
 		router.QueryService("svcX"),
-		router.QueryStrategy(router.AdvertiseBest),
 	}
 
 	routes, err = table.Query(query...)
 	if err != nil {
-		t.Errorf("error looking up routes: %s", err)
+		t.Fatalf("error looking up routes: %s", err)
 	}
 
-	if len(routes) != 1 {
-		t.Errorf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes))
+	if len(routes) != 2 {
+		t.Fatalf("incorrect number of routes returned. Expected: %d, found: %d", 1, len(routes))
 	}
 }
 
 func TestFallback(t *testing.T) {
 
 	r := &rtr{
-		subscribers: make(map[string]chan *router.Advert),
-		options:     router.DefaultOptions(),
+		options: router.DefaultOptions(),
 	}
 	route := router.Route{
 		Service: "go.micro.service.foo",
@@ -311,31 +311,30 @@ func TestFallback(t *testing.T) {
 
 	rts, err := r.Lookup(router.QueryService("go.micro.service.foo"))
 	if err != nil {
-		t.Errorf("error looking up service %s", err)
+		t.Fatalf("error looking up service %s", err)
 	}
 	if len(rts) != 1 {
-		t.Errorf("incorrect number of routes returned %d", len(rts))
+		t.Fatalf("incorrect number of routes returned %d", len(rts))
 	}
 
 	// deleting from the table but the next query should invoke the fallback that we passed during new table creation
 	if err := r.table.Delete(route); err != nil {
-		t.Errorf("error deleting route %s", err)
+		t.Fatalf("error deleting route %s", err)
 	}
 
 	rts, err = r.Lookup(router.QueryService("go.micro.service.foo"))
 	if err != nil {
-		t.Errorf("error looking up service %s", err)
+		t.Fatalf("error looking up service %s", err)
 	}
 	if len(rts) != 1 {
-		t.Errorf("incorrect number of routes returned %d", len(rts))
+		t.Fatalf("incorrect number of routes returned %d", len(rts))
 	}
 
 }
 
 func TestFallbackError(t *testing.T) {
 	r := &rtr{
-		subscribers: make(map[string]chan *router.Advert),
-		options:     router.DefaultOptions(),
+		options: router.DefaultOptions(),
 	}
 	r.table = newTable(func(s string) ([]router.Route, error) {
 		return nil, fmt.Errorf("ERROR")
@@ -343,7 +342,7 @@ func TestFallbackError(t *testing.T) {
 	r.start()
 	_, err := r.Lookup(router.QueryService("go.micro.service.foo"))
 	if err == nil {
-		t.Errorf("expected error looking up service but none returned")
+		t.Fatalf("expected error looking up service but none returned")
 	}
 
 }