etcd: New function signature updated

Now etcd.New accepts a minimal interface instead of a concrete
implementation. This makes it easier to use mocks when etcd.New
is called inside some code.

Author: oleg-jukovec

CHANGELOG.md

@@ -11,6 +11,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Changed
 
+- driver.etcd: etcd.New now accepts an interface that is compatible with
+  `*etcdclientv3.Client` instead of the concrete type, which should not cause
+  any issues when upgrading the version.
+
 ### Fixed
 
 ## [v1.1.2] - 2026-03-30

driver/etcd/etcd.go

@@ -18,9 +18,13 @@ import (
 	"github.com/tarantool/go-storage/watch"
 )
 
-// Client defines the minimal interface needed for etcd operations.
+// Client defines the minimal interface needed for etcd operations. It
+// is compatible with etcdclientv3.Client.
+//
 // This allows for easier testing and mock implementations.
 type Client interface {
+	Watcher
+
 	// Txn creates a new transaction.
 	Txn(ctx context.Context) etcd.Txn
 }
@@ -59,62 +63,18 @@ var (
 	errUnsupportedOperationType    = errors.New("unsupported operation type")
 )
 
-// etcdClientAdapter wraps etcd.Client to implement our Client interface.
-type etcdClientAdapter struct {
-	client *etcd.Client
-}
-
-func (a *etcdClientAdapter) Txn(ctx context.Context) etcd.Txn {
-	return a.client.Txn(ctx)
-}
-
-// etcdWatcherAdapter wraps etcd.Watcher to implement our Watcher interface.
-type etcdWatcherAdapter struct {
-	watcher etcd.Watcher
-}
-
-func (a *etcdWatcherAdapter) Watch(ctx context.Context, key string, opts ...etcd.OpOption) etcd.WatchChan {
-	return a.watcher.Watch(ctx, key, opts...)
-}
-
-func (a *etcdWatcherAdapter) Close() error {
-	return fmt.Errorf("failed to close: %w", a.watcher.Close())
-}
-
 // etcdWatcherFactory implements WatcherFactory for etcd clients.
 type etcdWatcherFactory struct{}
 
 func (f *etcdWatcherFactory) NewWatcher(client Client) Watcher {
-	// For etcd clients, we need access to the underlying client.
-	if adapter, ok := client.(*etcdClientAdapter); ok {
-		return &etcdWatcherAdapter{
-			watcher: etcd.NewWatcher(adapter.client),
-		}
-	}
-
-	// For other implementations, return a no-op watcher.
-	return &noopWatcher{}
-}
-
-// noopWatcher is a no-op implementation of Watcher for non-etcd clients.
-type noopWatcher struct{}
-
-func (w *noopWatcher) Watch(_ context.Context, _ string, _ ...etcd.OpOption) etcd.WatchChan {
-	ch := make(chan etcd.WatchResponse)
-	close(ch)
-
-	return ch
-}
-
-func (w *noopWatcher) Close() error {
-	return nil
+	return client
 }
 
 // New creates a new etcd driver instance using an existing etcd client.
 // The client should be properly configured and connected to an etcd cluster.
-func New(client *etcd.Client) *Driver {
+func New(client Client) *Driver {
 	return &Driver{
-		client:         &etcdClientAdapter{client: client},
+		client:         client,
 		watcherFactory: &etcdWatcherFactory{},
 	}
 }