NOISSUE - Rename package aliases uuidProvider into uuid

auth/api/grpc/endpoint_test.go

@@ -35,10 +35,10 @@ var svc auth.Service
 func newService() auth.Service {
 	repo := mocks.NewKeyRepository()
 	groupRepo := mocks.NewGroupRepository()
-	uuidProvider := uuid.NewMock()
+	idProvider := uuid.NewMock()
 	t := jwt.New(secret)
 
-	return auth.New(repo, groupRepo, uuidProvider, t)
+	return auth.New(repo, groupRepo, idProvider, t)
 }
 
 func startGRPCServer(svc auth.Service, port int) {

auth/api/http/endpoint_test.go

@@ -65,9 +65,9 @@ func (tr testRequest) make() (*http.Response, error) {
 func newService() auth.Service {
 	repo := mocks.NewKeyRepository()
 	groupRepo := mocks.NewGroupRepository()
-	uuidProvider := uuid.NewMock()
+	idProvider := uuid.NewMock()
 	t := jwt.New(secret)
-	return auth.New(repo, groupRepo, uuidProvider, t)
+	return auth.New(repo, groupRepo, idProvider, t)
 }
 
 func newServer(svc auth.Service) *httptest.Server {

auth/postgres/key_test.go

@@ -12,18 +12,26 @@ import (
 	"github.com/mainflux/mainflux/auth"
 	"github.com/mainflux/mainflux/auth/postgres"
 	"github.com/mainflux/mainflux/pkg/errors"
-	uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/opentracing/opentracing-go"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+const email = "user-save@example.com"
+
+var (
+	expTime    = time.Now().Add(5 * time.Minute)
+	idProvider = uuid.New()
 )
 
 func TestKeySave(t *testing.T) {
 	dbMiddleware := postgres.NewDatabase(db)
 	repo := postgres.New(dbMiddleware)
 
-	email := "user-save@example.com"
-	expTime := time.Now().Add(5 * time.Minute)
-	id, _ := uuidProvider.New().ID()
+	id, err := idProvider.ID()
+	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
+
 	cases := []struct {
 		desc string
 		key  auth.Key
@@ -63,17 +71,17 @@ func TestKeyRetrieve(t *testing.T) {
 	dbMiddleware := postgres.NewDatabase(db)
 	repo := postgres.New(dbMiddleware)
 
-	email := "user-save@example.com"
-	expTime := time.Now().Add(5 * time.Minute)
-	id, _ := uuidProvider.New().ID()
+	id, err := idProvider.ID()
+	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
+
 	key := auth.Key{
 		Subject:   email,
 		IssuedAt:  time.Now(),
 		ExpiresAt: expTime,
 		ID:        id,
 		IssuerID:  id,
 	}
-	_, err := repo.Save(context.Background(), key)
+	_, err = repo.Save(context.Background(), key)
 	assert.Nil(t, err, fmt.Sprintf("Storing Key expected to succeed: %s", err))
 	cases := []struct {
 		desc  string
@@ -111,17 +119,17 @@ func TestKeyRemove(t *testing.T) {
 	dbMiddleware := postgres.NewDatabase(db)
 	repo := postgres.New(dbMiddleware)
 
-	email := "user-save@example.com"
-	expTime := time.Now().Add(5 * time.Minute)
-	id, _ := uuidProvider.New().ID()
+	id, err := idProvider.ID()
+	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
+
 	key := auth.Key{
 		Subject:   email,
 		IssuedAt:  time.Now(),
 		ExpiresAt: expTime,
 		ID:        id,
 		IssuerID:  id,
 	}
-	_, err := repo.Save(opentracing.ContextWithSpan(context.Background(), opentracing.StartSpan("")), key)
+	_, err = repo.Save(opentracing.ContextWithSpan(context.Background(), opentracing.StartSpan("")), key)
 	assert.Nil(t, err, fmt.Sprintf("Storing Key expected to succeed: %s", err))
 	cases := []struct {
 		desc  string

auth/service.go

@@ -91,18 +91,18 @@ var _ Service = (*service)(nil)
 type service struct {
 	keys         KeyRepository
 	groups       groups.Repository
-	uuidProvider mainflux.IDProvider
+	idProvider   mainflux.IDProvider
 	ulidProvider mainflux.IDProvider
 	tokenizer    Tokenizer
 }
 
 // New instantiates the auth service implementation.
-func New(keys KeyRepository, groups groups.Repository, up mainflux.IDProvider, tokenizer Tokenizer) Service {
+func New(keys KeyRepository, groups groups.Repository, idp mainflux.IDProvider, tokenizer Tokenizer) Service {
 	return &service{
 		tokenizer:    tokenizer,
 		keys:         keys,
 		groups:       groups,
-		uuidProvider: up,
+		idProvider:   idp,
 		ulidProvider: ulid.New(),
 	}
 }
@@ -184,7 +184,7 @@ func (svc service) userKey(ctx context.Context, token string, key Key) (Key, str
 		key.Subject = sub
 	}
 
-	keyID, err := svc.uuidProvider.ID()
+	keyID, err := svc.idProvider.ID()
 	if err != nil {
 		return Key{}, "", errors.Wrap(errIssueUser, err)
 	}

auth/service_test.go

@@ -26,9 +26,9 @@ const (
 func newService() auth.Service {
 	repo := mocks.NewKeyRepository()
 	groupRepo := mocks.NewGroupRepository()
-	uuidProvider := uuid.NewMock()
+	idProvider := uuid.NewMock()
 	t := jwt.New(secret)
-	return auth.New(repo, groupRepo, uuidProvider, t)
+	return auth.New(repo, groupRepo, idProvider, t)
 }
 
 func TestIssue(t *testing.T) {

cmd/auth/main.go

@@ -22,7 +22,7 @@ import (
 	"github.com/mainflux/mainflux/auth/postgres"
 	"github.com/mainflux/mainflux/auth/tracing"
 	"github.com/mainflux/mainflux/logger"
-	uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/opentracing/opentracing-go"
 	stdprometheus "github.com/prometheus/client_golang/prometheus"
 	jconfig "github.com/uber/jaeger-client-go/config"
@@ -182,9 +182,10 @@ func newService(db *sqlx.DB, tracer opentracing.Tracer, secret string, logger lo
 	groupsRepo := postgres.NewGroupRepo(database)
 	groupsRepo = tracing.GroupRepositoryMiddleware(tracer, groupsRepo)
 
-	up := uuidProvider.New()
+	idProvider := uuid.New()
 	t := jwt.New(secret)
-	svc := auth.New(keysRepo, groupsRepo, up, t)
+
+	svc := auth.New(keysRepo, groupsRepo, idProvider, t)
 	svc = api.LoggingMiddleware(svc, logger)
 	svc = api.MetricsMiddleware(
 		svc,

cmd/things/main.go

@@ -27,7 +27,7 @@ import (
 	"github.com/mainflux/mainflux"
 	authapi "github.com/mainflux/mainflux/auth/api/grpc"
 	"github.com/mainflux/mainflux/logger"
-	uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/mainflux/mainflux/things"
 	"github.com/mainflux/mainflux/things/api"
 	authgrpcapi "github.com/mainflux/mainflux/things/api/auth/grpc"
@@ -68,8 +68,8 @@ const (
 	defSingleUserEmail = ""
 	defSingleUserToken = ""
 	defJaegerURL       = ""
-	defAuthnURL        = "localhost:8181"
-	defAuthnTimeout    = "1s"
+	defAuthURL         = "localhost:8181"
+	defAuthTimeout     = "1s"
 
 	envLogLevel        = "MF_THINGS_LOG_LEVEL"
 	envDBHost          = "MF_THINGS_DB_HOST"
@@ -97,8 +97,8 @@ const (
 	envSingleUserEmail = "MF_THINGS_SINGLE_USER_EMAIL"
 	envSingleUserToken = "MF_THINGS_SINGLE_USER_TOKEN"
 	envJaegerURL       = "MF_JAEGER_URL"
-	envAuthnURL        = "MF_AUTH_GRPC_URL"
-	envAuthnTimeout    = "MF_AUTH_GRPC_TIMEOUT"
+	envAuthURL         = "MF_AUTH_GRPC_URL"
+	envAuthTimeout     = "MF_AUTH_GRPC_TIMEOUT"
 )
 
 type config struct {
@@ -120,8 +120,8 @@ type config struct {
 	singleUserEmail string
 	singleUserToken string
 	jaegerURL       string
-	authnURL        string
-	authnTimeout    time.Duration
+	authURL         string
+	authTimeout     time.Duration
 }
 
 func main() {
@@ -179,9 +179,9 @@ func loadConfig() config {
 		log.Fatalf("Invalid value passed for %s\n", envClientTLS)
 	}
 
-	authnTimeout, err := time.ParseDuration(mainflux.Env(envAuthnTimeout, defAuthnTimeout))
+	authTimeout, err := time.ParseDuration(mainflux.Env(envAuthTimeout, defAuthTimeout))
 	if err != nil {
-		log.Fatalf("Invalid %s value: %s", envAuthnTimeout, err.Error())
+		log.Fatalf("Invalid %s value: %s", envAuthTimeout, err.Error())
 	}
 
 	dbConfig := postgres.Config{
@@ -215,8 +215,8 @@ func loadConfig() config {
 		singleUserEmail: mainflux.Env(envSingleUserEmail, defSingleUserEmail),
 		singleUserToken: mainflux.Env(envSingleUserToken, defSingleUserToken),
 		jaegerURL:       mainflux.Env(envJaegerURL, defJaegerURL),
-		authnURL:        mainflux.Env(envAuthnURL, defAuthnURL),
-		authnTimeout:    authnTimeout,
+		authURL:         mainflux.Env(envAuthURL, defAuthURL),
+		authTimeout:     authTimeout,
 	}
 }
 
@@ -273,7 +273,7 @@ func createAuthClient(cfg config, tracer opentracing.Tracer, logger logger.Logge
 	}
 
 	conn := connectToAuth(cfg, logger)
-	return authapi.NewClient(tracer, conn, cfg.authnTimeout), conn.Close
+	return authapi.NewClient(tracer, conn, cfg.authTimeout), conn.Close
 }
 
 func connectToAuth(cfg config, logger logger.Logger) *grpc.ClientConn {
@@ -292,7 +292,7 @@ func connectToAuth(cfg config, logger logger.Logger) *grpc.ClientConn {
 		logger.Info("gRPC communication is not encrypted")
 	}
 
-	conn, err := grpc.Dial(cfg.authnURL, opts...)
+	conn, err := grpc.Dial(cfg.authURL, opts...)
 	if err != nil {
 		logger.Error(fmt.Sprintf("Failed to connect to auth service: %s", err))
 		os.Exit(1)
@@ -318,9 +318,9 @@ func newService(auth mainflux.AuthServiceClient, dbTracer opentracing.Tracer, ca
 
 	thingCache := rediscache.NewThingCache(cacheClient)
 	thingCache = tracing.ThingCacheMiddleware(cacheTracer, thingCache)
-	up := uuidProvider.New()
+	idProvider := uuid.New()
 
-	svc := things.New(auth, thingsRepo, channelsRepo, groupsRepo, chanCache, thingCache, up)
+	svc := things.New(auth, thingsRepo, channelsRepo, groupsRepo, chanCache, thingCache, idProvider)
 	svc = rediscache.NewEventStoreMiddleware(svc, esClient)
 	svc = api.LoggingMiddleware(svc, logger)
 	svc = api.MetricsMiddleware(

cmd/twins/main.go

@@ -22,7 +22,7 @@ import (
 	"github.com/mainflux/mainflux/logger"
 	"github.com/mainflux/mainflux/pkg/messaging"
 	"github.com/mainflux/mainflux/pkg/messaging/nats"
-	uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	localusers "github.com/mainflux/mainflux/things/users"
 	"github.com/mainflux/mainflux/twins"
 	"github.com/mainflux/mainflux/twins/api"
@@ -269,11 +269,11 @@ func newService(ps messaging.PubSub, chanID string, users mainflux.AuthServiceCl
 	stateRepo := twmongodb.NewStateRepository(db)
 	stateRepo = tracing.StateRepositoryMiddleware(dbTracer, stateRepo)
 
-	up := uuidProvider.New()
+	idProvider := uuid.New()
 	twinCache := rediscache.NewTwinCache(cacheClient)
 	twinCache = tracing.TwinCacheMiddleware(cacheTracer, twinCache)
 
-	svc := twins.New(ps, users, twinRepo, twinCache, stateRepo, up, chanID, logger)
+	svc := twins.New(ps, users, twinRepo, twinCache, stateRepo, idProvider, chanID, logger)
 	svc = api.LoggingMiddleware(svc, logger)
 	svc = api.MetricsMiddleware(
 		svc,

cmd/users/main.go

@@ -17,6 +17,7 @@ import (
 	"time"
 
 	"github.com/mainflux/mainflux/internal/email"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/mainflux/mainflux/users"
 	"github.com/mainflux/mainflux/users/bcrypt"
 	"github.com/mainflux/mainflux/users/emailer"
@@ -284,7 +285,9 @@ func newService(db *sqlx.DB, tracer opentracing.Tracer, auth mainflux.AuthServic
 		logger.Error(fmt.Sprintf("Failed to configure e-mailing util: %s", err.Error()))
 	}
 
-	svc := users.New(userRepo, groupRepo, hasher, auth, emailer)
+	idProvider := uuid.New()
+
+	svc := users.New(userRepo, groupRepo, hasher, auth, emailer, idProvider)
 	svc = api.LoggingMiddleware(svc, logger)
 	svc = api.MetricsMiddleware(
 		svc,

pkg/sdk/go/things_test.go

@@ -47,9 +47,9 @@ func newThingsService(tokens map[string]string) things.Service {
 	channelsRepo := mocks.NewChannelRepository(thingsRepo, conns)
 	chanCache := mocks.NewChannelCache()
 	thingCache := mocks.NewThingCache()
-	uuidProvider := uuid.NewMock()
+	idProvider := uuid.NewMock()
 
-	return things.New(auth, thingsRepo, channelsRepo, nil, chanCache, thingCache, uuidProvider)
+	return things.New(auth, thingsRepo, channelsRepo, nil, chanCache, thingCache, idProvider)
 }
 
 func newThingsServer(svc things.Service) *httptest.Server {

pkg/sdk/go/users_test.go

@@ -12,6 +12,7 @@ import (
 
 	"github.com/mainflux/mainflux"
 	sdk "github.com/mainflux/mainflux/pkg/sdk/go"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/mainflux/mainflux/users"
 	"github.com/mainflux/mainflux/users/api"
 	"github.com/mainflux/mainflux/users/mocks"
@@ -29,8 +30,9 @@ func newUserService() users.Service {
 	hasher := mocks.NewHasher()
 	auth := mocks.NewAuthService(map[string]string{"user@example.com": "user@example.com"})
 	emailer := mocks.NewEmailer()
+	idProvider := uuid.New()
 
-	return users.New(usersRepo, groupsRepo, hasher, auth, emailer)
+	return users.New(usersRepo, groupsRepo, hasher, auth, emailer, idProvider)
 }
 
 func newUserServer(svc users.Service) *httptest.Server {

readers/cassandra/messages_test.go

@@ -36,6 +36,8 @@ var (
 	vb          = true
 	vd          = "base64"
 	sum float64 = 42
+
+	idProvider = uuid.New()
 )
 
 func TestReadSenml(t *testing.T) {
@@ -47,11 +49,11 @@ func TestReadSenml(t *testing.T) {
 	defer session.Close()
 	writer := writer.New(session)
 
-	chanID, err := uuid.New().ID()
+	chanID, err := idProvider.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-	pubID, err := uuid.New().ID()
+	pubID, err := idProvider.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-	pub2ID, err := uuid.New().ID()
+	pub2ID, err := idProvider.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	m := senml.Message{

readers/influxdb/messages_test.go

@@ -8,7 +8,7 @@ import (
 	influxdata "github.com/influxdata/influxdb/client/v2"
 	iwriter "github.com/mainflux/mainflux/consumers/writers/influxdb"
 	"github.com/mainflux/mainflux/pkg/transformers/senml"
-	uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/mainflux/mainflux/readers"
 	ireader "github.com/mainflux/mainflux/readers/influxdb"
 
@@ -34,17 +34,18 @@ var (
 	vd          = "dataValue"
 	sum float64 = 42
 
-	client influxdata.Client
+	client     influxdata.Client
+	idProvider = uuid.New()
 )
 
 func TestReadAll(t *testing.T) {
 	writer := iwriter.New(client, testDB)
 
-	chanID, err := uuidProvider.New().ID()
+	chanID, err := idProvider.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-	pubID, err := uuidProvider.New().ID()
+	pubID, err := idProvider.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-	pub2ID, err := uuidProvider.New().ID()
+	pub2ID, err := idProvider.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	m := senml.Message{