Add cassandra option test

docs/contributing/coding-style.md

@@ -451,20 +451,27 @@ The implementation may differ based on your use case.
 In Vald, the functional option pattern is widely used in Vald.
 You can refer to [this section](#Struct-initialization) for more details of the use case of this pattern.
 
+We provide the following errors to describe the error to apply the option.
+
+| Error | Description |
+|----|----|
+| errors.ErrInvalidOption | Error to apply the option, and the error is ignorable |
+| errors.ErrCriticalOption | Critical error to apply the option, the error cannot be ignored and should be handled |
+
 We strongly recommend the following implementation to set the value using functional option.
 
 If an invalid value is set to the functional option, the `ErrInvalidOption` error defined in the [internal/errors/option.go](https://github.com/vdaas/vald/blob/master/internal/errors/option.go) should be returned.
 
-The name argument (the first argument) of the `ErrInvalidOption` error should be the same as the functional option name without the `With` prefix. 
+The name argument (the first argument) of the `ErrInvalidOption` error should be the same as the functional option name without the `With` prefix.
 
-For example, the functional option name `WithVersion` should return the error with the argument `name` as `version`.
 
+For example, the functional option name `WithVersion` should return the error with the argument `name` as `version`.
 
 ```go
 func WithVersion(version string) Option {
     return func(c *client) error {
         if len(version) == 0 {
-            return errors.ErrInvalidOption("version", version)
+            return errors.NewErrInvalidOption("version", version)
         }
         c.version = version
         return nil
@@ -478,11 +485,11 @@ We recommend the following implementation to parse the time string and set the t
 func WithTimeout(dur string) Option {
     func(c *client) error {
         if dur == "" {
-            return errors.ErrInvalidOption("timeout", dur)
+            return errors.NewErrInvalidOption("timeout", dur)
         }
         d, err := timeutil.Parse(dur)
         if err != nil {
-            return err
+            return errors.NewErrInvalidOption("timeout", dur, err)
         }
         c.timeout = d
         return nil
@@ -496,7 +503,7 @@ We recommend the following implementation to append the value to the slice if th
 func WithHosts(hosts ...string) Option {
     return func(c *client) error {
         if len(hosts) == 0 {
-            return errors.ErrInvalidOption("hosts", hosts)
+            return errors.NewErrInvalidOption("hosts", hosts)
         }
         if c.hosts == nil {
             c.hosts = hosts
@@ -508,16 +515,44 @@ func WithHosts(hosts ...string) Option {
 }
 ```
 
-We recommend the following implementation to apply the options.
+If the functional option error is a critical error, we should return `ErrCriticalOption` error instead of `ErrInvalidOption`.
+
+```go
+func WithConnectTimeout(dur string) Option {
+    return func(c *client) error {
+        if dur == "" {
+            return errors.NewErrInvalidOption("connectTimeout", dur)
+        }
+        d, err := timeutil.Parse(dur)
+        if err != nil {
+            return errors.NewErrCriticalOption("connectTimeout", dur, err)
+        }
+
+        c.connectTimeout = d
+        return nil
+    }
+}
+```
+
+In the caller side, we need to handle the error returned from the functional option.
 
 If the option failed to apply, an error wrapped with `ErrOptionFailed` defined in the [internal/errors/errors.go](https://github.com/vdaas/vald/blob/master/internal/errors/errors.go) should be returned.
 
+We recommend the following implementation to apply the options.
+
 ```go
 func New(opts ...Option) (Server, error) {
     srv := new(server)
     for _, opt := range opts {
         if err := opt(srv); err != nil {
-            return nil, errors.ErrOptionFailed(err, reflect.ValueOf(opt))
+            werr := errors.ErrOptionFailed(err, reflect.ValueOf(opt))
+
+            e := new(errors.ErrCriticalOption)
+			if errors.As(err, &e) {
+                log.Error(werr)
+                return nil, werr
+            }
+            log.Warn(werr)
         }
     }
 }

internal/db/nosql/cassandra/cassandra.go

@@ -26,6 +26,7 @@ import (
 	"github.com/scylladb/gocqlx"
 	"github.com/scylladb/gocqlx/qb"
 	"github.com/vdaas/vald/internal/errors"
+	"github.com/vdaas/vald/internal/log"
 )
 
 var (
@@ -50,29 +51,18 @@ type Cassandra interface {
 	Query(stmt string, names []string) *Queryx
 }
 
-type Session = gocql.Session
-type Cmp = qb.Cmp
-type BatchBuilder = qb.BatchBuilder
-type InsertBuilder = qb.InsertBuilder
-type DeleteBuilder = qb.DeleteBuilder
-type UpdateBuilder = qb.UpdateBuilder
-type Queryx = gocqlx.Queryx
+type (
+	Session       = gocql.Session
+	Cmp           = qb.Cmp
+	BatchBuilder  = qb.BatchBuilder
+	InsertBuilder = qb.InsertBuilder
+	DeleteBuilder = qb.DeleteBuilder
+	UpdateBuilder = qb.UpdateBuilder
+	Queryx        = gocqlx.Queryx
+)
 
-type client struct {
-	hosts          []string
-	cqlVersion     string
-	protoVersion   int
-	timeout        time.Duration
-	connectTimeout time.Duration
-	port           int
-	keyspace       string
-	numConns       int
-	consistency    gocql.Consistency
-	compressor     gocql.Compressor
-	username       string
-	password       string
-	authProvider   func(h *gocql.HostInfo) (gocql.Authenticator, error)
-	retryPolicy    struct {
+type (
+	retryPolicy struct {
 		numRetries  int
 		minDuration time.Duration
 		maxDuration time.Duration
@@ -93,42 +83,68 @@ type client struct {
 		dcHost    string
 		whiteList []string
 	}
-	socketKeepalive          time.Duration
-	maxPreparedStmts         int
-	maxRoutingKeyInfo        int
-	pageSize                 int
-	serialConsistency        gocql.SerialConsistency
-	tls                      *tls.Config
-	tlsCertPath              string
-	tlsKeyPath               string
-	tlsCAPath                string
-	enableHostVerification   bool
-	defaultTimestamp         bool
-	reconnectInterval        time.Duration
-	maxWaitSchemaAgreement   time.Duration
-	ignorePeerAddr           bool
-	disableInitialHostLookup bool
-	disableNodeStatusEvents  bool
-	disableTopologyEvents    bool
-	disableSchemaEvents      bool
-	disableSkipMetadata      bool
-	queryObserver            QueryObserver
-	batchObserver            BatchObserver
-	connectObserver          ConnectObserver
-	frameHeaderObserver      FrameHeaderObserver
-	defaultIdempotence       bool
-	dialer                   gocql.Dialer
-	writeCoalesceWaitTime    time.Duration
+	client struct {
+		hosts                    []string
+		cqlVersion               string
+		protoVersion             int
+		timeout                  time.Duration
+		connectTimeout           time.Duration
+		port                     int
+		keyspace                 string
+		numConns                 int
+		consistency              gocql.Consistency
+		compressor               gocql.Compressor
+		username                 string
+		password                 string
+		authProvider             func(h *gocql.HostInfo) (gocql.Authenticator, error)
+		retryPolicy              retryPolicy
+		reconnectionPolicy       reconnectionPolicy
+		poolConfig               poolConfig
+		hostFilter               hostFilter
+		socketKeepalive          time.Duration
+		maxPreparedStmts         int
+		maxRoutingKeyInfo        int
+		pageSize                 int
+		serialConsistency        gocql.SerialConsistency
+		tls                      *tls.Config
+		tlsCertPath              string
+		tlsKeyPath               string
+		tlsCAPath                string
+		enableHostVerification   bool
+		defaultTimestamp         bool
+		reconnectInterval        time.Duration
+		maxWaitSchemaAgreement   time.Duration
+		ignorePeerAddr           bool
+		disableInitialHostLookup bool
+		disableNodeStatusEvents  bool
+		disableTopologyEvents    bool
+		disableSchemaEvents      bool
+		disableSkipMetadata      bool
+		queryObserver            QueryObserver
+		batchObserver            BatchObserver
+		connectObserver          ConnectObserver
+		frameHeaderObserver      FrameHeaderObserver
+		defaultIdempotence       bool
+		dialer                   gocql.Dialer
+		writeCoalesceWaitTime    time.Duration
 
-	cluster *gocql.ClusterConfig
-	session *gocql.Session
-}
+		cluster *gocql.ClusterConfig
+		session *gocql.Session
+	}
+)
 
 func New(opts ...Option) (Cassandra, error) {
 	c := new(client)
 	for _, opt := range append(defaultOpts, opts...) {
 		if err := opt(c); err != nil {
-			return nil, errors.ErrOptionFailed(err, reflect.ValueOf(opt))
+			werr := errors.ErrOptionFailed(err, reflect.ValueOf(opt))
+
+			e := new(errors.ErrCriticalOption)
+			if errors.As(err, &e) {
+				log.Error(werr)
+				return nil, werr
+			}
+			log.Warn(werr)
 		}
 	}
 

internal/db/nosql/cassandra/cassandra_mock_test.go

@@ -0,0 +1,29 @@
+//
+// Copyright (C) 2019-2020 Vdaas.org Vald team ( kpango, rinx, kmrmt )
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+package cassandra
+
+import (
+	"context"
+	"net"
+)
+
+type DialerMock struct {
+	DialContextFunc func(ctx context.Context, network, addr string) (net.Conn, error)
+}
+
+func (dm *DialerMock) DialContext(ctx context.Context, network, addr string) (net.Conn, error) {
+	return dm.DialContextFunc(ctx, network, addr)
+}