MF-1154 - Move UUID provider to project root (#1172)

* MF-1154 - Move UUID provider to project root

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Use naming uuidProvider/up instead of identityProvider/idp

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Fix typo

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Mutualize UUID mocks

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

* Move uuid into pkg directory

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>

authn/api/grpc/endpoint_test.go

@@ -14,6 +14,7 @@ import (
 	grpcapi "github.com/mainflux/mainflux/authn/api/grpc"
 	"github.com/mainflux/mainflux/authn/jwt"
 	"github.com/mainflux/mainflux/authn/mocks"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/opentracing/opentracing-go/mocktracer"
 	"github.com/stretchr/testify/assert"
 	"golang.org/x/net/context"
@@ -32,10 +33,10 @@ var svc authn.Service
 
 func newService() authn.Service {
 	repo := mocks.NewKeyRepository()
-	idp := mocks.NewIdentityProvider()
+	uuidProvider := uuid.NewMock()
 	t := jwt.New(secret)
 
-	return authn.New(repo, idp, t)
+	return authn.New(repo, uuidProvider, t)
 }
 
 func startGRPCServer(svc authn.Service, port int) {

authn/api/http/endpoint_test.go

@@ -18,6 +18,7 @@ import (
 	httpapi "github.com/mainflux/mainflux/authn/api/http"
 	"github.com/mainflux/mainflux/authn/jwt"
 	"github.com/mainflux/mainflux/authn/mocks"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/opentracing/opentracing-go/mocktracer"
 	"github.com/stretchr/testify/assert"
 )
@@ -63,9 +64,9 @@ func (tr testRequest) make() (*http.Response, error) {
 
 func newService() authn.Service {
 	repo := mocks.NewKeyRepository()
-	idp := mocks.NewIdentityProvider()
+	uuidProvider := uuid.NewMock()
 	t := jwt.New(secret)
-	return authn.New(repo, idp, t)
+	return authn.New(repo, uuidProvider, t)
 }
 
 func newServer(svc authn.Service) *httptest.Server {

authn/mocks/idp.go

@@ -1,32 +0,0 @@
-// Copyright (c) Mainflux
-// SPDX-License-Identifier: Apache-2.0
-
-package mocks
-
-import (
-	"fmt"
-	"sync"
-
-	"github.com/mainflux/mainflux/authn"
-)
-
-var _ authn.IdentityProvider = (*identityProviderMock)(nil)
-
-type identityProviderMock struct {
-	mu      sync.Mutex
-	counter int
-}
-
-func (idp *identityProviderMock) ID() (string, error) {
-	idp.mu.Lock()
-	defer idp.mu.Unlock()
-
-	idp.counter++
-	return fmt.Sprintf("%s%012d", "123e4567-e89b-12d3-a456-", idp.counter), nil
-}
-
-// NewIdentityProvider creates "mirror" identity provider, i.e. generated
-// token will hold value provided by the caller.
-func NewIdentityProvider() authn.IdentityProvider {
-	return &identityProviderMock{}
-}

authn/postgres/key_test.go

@@ -11,8 +11,8 @@ import (
 
 	"github.com/mainflux/mainflux/authn"
 	"github.com/mainflux/mainflux/authn/postgres"
-	"github.com/mainflux/mainflux/authn/uuid"
 	"github.com/mainflux/mainflux/pkg/errors"
+	uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/opentracing/opentracing-go"
 	"github.com/stretchr/testify/assert"
 )
@@ -23,8 +23,7 @@ func TestKeySave(t *testing.T) {
 
 	email := "user-save@example.com"
 	expTime := time.Now().Add(5 * time.Minute)
-	idp := uuid.New()
-	id, _ := idp.ID()
+	id, _ := uuidProvider.New().ID()
 	cases := []struct {
 		desc string
 		key  authn.Key
@@ -64,8 +63,7 @@ func TestKeyRetrieve(t *testing.T) {
 
 	email := "user-save@example.com"
 	expTime := time.Now().Add(5 * time.Minute)
-	idp := uuid.New()
-	id, _ := idp.ID()
+	id, _ := uuidProvider.New().ID()
 	key := authn.Key{
 		Issuer:    email,
 		IssuedAt:  time.Now(),
@@ -112,8 +110,7 @@ func TestKeyRemove(t *testing.T) {
 
 	email := "user-save@example.com"
 	expTime := time.Now().Add(5 * time.Minute)
-	idp := uuid.New()
-	id, _ := idp.ID()
+	id, _ := uuidProvider.New().ID()
 	key := authn.Key{
 		Issuer:    email,
 		IssuedAt:  time.Now(),

authn/service.go

@@ -7,6 +7,7 @@ import (
 	"context"
 	"time"
 
+	"github.com/mainflux/mainflux"
 	"github.com/mainflux/mainflux/pkg/errors"
 )
 
@@ -60,17 +61,17 @@ type Service interface {
 var _ Service = (*service)(nil)
 
 type service struct {
-	keys      KeyRepository
-	idp       IdentityProvider
-	tokenizer Tokenizer
+	keys         KeyRepository
+	uuidProvider mainflux.UUIDProvider
+	tokenizer    Tokenizer
 }
 
 // New instantiates the auth service implementation.
-func New(keys KeyRepository, idp IdentityProvider, tokenizer Tokenizer) Service {
+func New(keys KeyRepository, up mainflux.UUIDProvider, tokenizer Tokenizer) Service {
 	return &service{
-		tokenizer: tokenizer,
-		keys:      keys,
-		idp:       idp,
+		tokenizer:    tokenizer,
+		keys:         keys,
+		uuidProvider: up,
 	}
 }
 
@@ -156,7 +157,7 @@ func (svc service) userKey(ctx context.Context, issuer string, key Key) (Key, er
 	}
 	key.Issuer = email
 
-	id, err := svc.idp.ID()
+	id, err := svc.uuidProvider.ID()
 	if err != nil {
 		return Key{}, errors.Wrap(errIssueUser, err)
 	}

authn/service_test.go

@@ -13,6 +13,7 @@ import (
 	"github.com/mainflux/mainflux/authn/jwt"
 	"github.com/mainflux/mainflux/authn/mocks"
 	"github.com/mainflux/mainflux/pkg/errors"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -23,9 +24,9 @@ const (
 
 func newService() authn.Service {
 	repo := mocks.NewKeyRepository()
-	idp := mocks.NewIdentityProvider()
+	uuidProvider := uuid.NewMock()
 	t := jwt.New(secret)
-	return authn.New(repo, idp, t)
+	return authn.New(repo, uuidProvider, t)
 }
 
 func TestIssue(t *testing.T) {

authn/uuid/idp.go

@@ -1,32 +0,0 @@
-// Copyright (c) Mainflux
-// SPDX-License-Identifier: Apache-2.0
-
-// Package uuid provides a UUID identity provider.
-package uuid
-
-import (
-	"github.com/gofrs/uuid"
-	"github.com/mainflux/mainflux/authn"
-	"github.com/mainflux/mainflux/pkg/errors"
-)
-
-// errGeneratingID indicates error in generating UUID
-var errGeneratingID = errors.New("failed to generate uuid")
-
-var _ authn.IdentityProvider = (*uuidIdentityProvider)(nil)
-
-type uuidIdentityProvider struct{}
-
-// New instantiates a UUID identity provider.
-func New() authn.IdentityProvider {
-	return &uuidIdentityProvider{}
-}
-
-func (idp *uuidIdentityProvider) ID() (string, error) {
-	id, err := uuid.NewV4()
-	if err != nil {
-		return "", errors.Wrap(errGeneratingID, err)
-	}
-
-	return id.String(), nil
-}

cmd/authn/main.go

@@ -21,8 +21,8 @@ import (
 	"github.com/mainflux/mainflux/authn/jwt"
 	"github.com/mainflux/mainflux/authn/postgres"
 	"github.com/mainflux/mainflux/authn/tracing"
-	mfidp "github.com/mainflux/mainflux/authn/uuid"
 	"github.com/mainflux/mainflux/logger"
+	uuidProvider "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"
@@ -179,9 +179,9 @@ func newService(db *sqlx.DB, tracer opentracing.Tracer, secret string, logger lo
 	database := postgres.NewDatabase(db)
 	repo := tracing.New(postgres.New(database), tracer)
 
-	idp := mfidp.New()
+	up := uuidProvider.New()
 	t := jwt.New(secret)
-	svc := authn.New(repo, idp, t)
+	svc := authn.New(repo, up, t)
 	svc = api.LoggingMiddleware(svc, logger)
 	svc = api.MetricsMiddleware(
 		svc,

cmd/things/main.go

@@ -35,7 +35,7 @@ import (
 	"github.com/mainflux/mainflux/things/postgres"
 	rediscache "github.com/mainflux/mainflux/things/redis"
 	localusers "github.com/mainflux/mainflux/things/users"
-	"github.com/mainflux/mainflux/things/uuid"
+	uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
 	stdprometheus "github.com/prometheus/client_golang/prometheus"
 	jconfig "github.com/uber/jaeger-client-go/config"
 	"google.golang.org/grpc"
@@ -315,9 +315,9 @@ func newService(auth mainflux.AuthNServiceClient, dbTracer opentracing.Tracer, c
 
 	thingCache := rediscache.NewThingCache(cacheClient)
 	thingCache = tracing.ThingCacheMiddleware(cacheTracer, thingCache)
-	idp := uuid.New()
+	up := uuidProvider.New()
 
-	svc := things.New(auth, thingsRepo, channelsRepo, chanCache, thingCache, idp)
+	svc := things.New(auth, thingsRepo, channelsRepo, chanCache, thingCache, up)
 	svc = rediscache.NewEventStoreMiddleware(svc, esClient)
 	svc = api.LoggingMiddleware(svc, logger)
 	svc = api.MetricsMiddleware(

cmd/twins/main.go

@@ -27,7 +27,7 @@ import (
 	twapi "github.com/mainflux/mainflux/twins/api/http"
 	twmongodb "github.com/mainflux/mainflux/twins/mongodb"
 	"github.com/mainflux/mainflux/twins/tracing"
-	"github.com/mainflux/mainflux/twins/uuid"
+	uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
 	opentracing "github.com/opentracing/opentracing-go"
 	stdprometheus "github.com/prometheus/client_golang/prometheus"
 	jconfig "github.com/uber/jaeger-client-go/config"
@@ -239,9 +239,9 @@ func newService(ps messaging.PubSub, chanID string, users mainflux.AuthNServiceC
 	stateRepo := twmongodb.NewStateRepository(db)
 	stateRepo = tracing.StateRepositoryMiddleware(dbTracer, stateRepo)
 
-	idp := uuid.New()
+	up := uuidProvider.New()
 
-	svc := twins.New(ps, users, twinRepo, stateRepo, idp, chanID, logger)
+	svc := twins.New(ps, users, twinRepo, stateRepo, up, chanID, logger)
 	svc = api.LoggingMiddleware(svc, logger)
 	svc = api.MetricsMiddleware(
 		svc,

pkg/sdk/go/things_test.go

@@ -11,6 +11,7 @@ import (
 	"testing"
 
 	sdk "github.com/mainflux/mainflux/pkg/sdk/go"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/mainflux/mainflux/things"
 	httpapi "github.com/mainflux/mainflux/things/api/things/http"
 	"github.com/mainflux/mainflux/things/mocks"
@@ -46,9 +47,9 @@ func newThingsService(tokens map[string]string) things.Service {
 	channelsRepo := mocks.NewChannelRepository(thingsRepo, conns)
 	chanCache := mocks.NewChannelCache()
 	thingCache := mocks.NewThingCache()
-	idp := mocks.NewIdentityProvider()
+	uuidProvider := uuid.NewMock()
 
-	return things.New(auth, thingsRepo, channelsRepo, chanCache, thingCache, idp)
+	return things.New(auth, thingsRepo, channelsRepo, chanCache, thingCache, uuidProvider)
 }
 
 func newThingsServer(svc things.Service) *httptest.Server {

pkg/uuid/mock.go

@@ -0,0 +1,35 @@
+// Copyright (c) Mainflux
+// SPDX-License-Identifier: Apache-2.0
+
+package uuid
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/mainflux/mainflux"
+)
+
+// Prefix represents the prefix used to generate UUID mocks
+const Prefix = "123e4567-e89b-12d3-a456-"
+
+var _ mainflux.UUIDProvider = (*uuidProviderMock)(nil)
+
+type uuidProviderMock struct {
+	mu      sync.Mutex
+	counter int
+}
+
+func (up *uuidProviderMock) ID() (string, error) {
+	up.mu.Lock()
+	defer up.mu.Unlock()
+
+	up.counter++
+	return fmt.Sprintf("%s%012d", Prefix, up.counter), nil
+}
+
+// NewMock creates "mirror" uuid provider, i.e. generated
+// token will hold value provided by the caller.
+func NewMock() mainflux.UUIDProvider {
+	return &uuidProviderMock{}
+}

pkg/uuid/uuid.go

@@ -6,23 +6,23 @@ package uuid
 
 import (
 	"github.com/gofrs/uuid"
+	"github.com/mainflux/mainflux"
 	"github.com/mainflux/mainflux/pkg/errors"
-	"github.com/mainflux/mainflux/things"
 )
 
 // ErrGeneratingID indicates error in generating UUID
 var ErrGeneratingID = errors.New("generating id failed")
 
-var _ things.IdentityProvider = (*uuidIdentityProvider)(nil)
+var _ mainflux.UUIDProvider = (*uuidProvider)(nil)
 
-type uuidIdentityProvider struct{}
+type uuidProvider struct{}
 
-// New instantiates a UUID identity provider.
-func New() things.IdentityProvider {
-	return &uuidIdentityProvider{}
+// New instantiates a UUID provider.
+func New() mainflux.UUIDProvider {
+	return &uuidProvider{}
 }
 
-func (idp *uuidIdentityProvider) ID() (string, error) {
+func (up *uuidProvider) ID() (string, error) {
 	id, err := uuid.NewV4()
 	if err != nil {
 		return "", errors.Wrap(ErrGeneratingID, err)

things/api/auth/grpc/setup_test.go

@@ -10,6 +10,7 @@ import (
 	"testing"
 
 	"github.com/mainflux/mainflux"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/mainflux/mainflux/things"
 	grpcapi "github.com/mainflux/mainflux/things/api/auth/grpc"
 	"github.com/mainflux/mainflux/things/mocks"
@@ -47,7 +48,7 @@ func newService(tokens map[string]string) things.Service {
 	channelsRepo := mocks.NewChannelRepository(thingsRepo, conns)
 	chanCache := mocks.NewChannelCache()
 	thingCache := mocks.NewThingCache()
-	idp := mocks.NewIdentityProvider()
+	uuidProvider := uuid.NewMock()
 
-	return things.New(auth, thingsRepo, channelsRepo, chanCache, thingCache, idp)
+	return things.New(auth, thingsRepo, channelsRepo, chanCache, thingCache, uuidProvider)
 }

things/api/auth/http/endpoint_test.go

@@ -15,6 +15,7 @@ import (
 
 	"github.com/opentracing/opentracing-go/mocktracer"
 
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/mainflux/mainflux/things"
 	httpapi "github.com/mainflux/mainflux/things/api/auth/http"
 	"github.com/mainflux/mainflux/things/mocks"
@@ -72,9 +73,9 @@ func newService(tokens map[string]string) things.Service {
 	channelsRepo := mocks.NewChannelRepository(thingsRepo, conns)
 	chanCache := mocks.NewChannelCache()
 	thingCache := mocks.NewThingCache()
-	idp := mocks.NewIdentityProvider()
+	uuidProvider := uuid.NewMock()
 
-	return things.New(auth, thingsRepo, channelsRepo, chanCache, thingCache, idp)
+	return things.New(auth, thingsRepo, channelsRepo, chanCache, thingCache, uuidProvider)
 }
 
 func newServer(svc things.Service) *httptest.Server {

things/api/things/http/endpoint_test.go

@@ -16,6 +16,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/mainflux/mainflux/things"
 	httpapi "github.com/mainflux/mainflux/things/api/things/http"
 	"github.com/mainflux/mainflux/things/mocks"
@@ -77,9 +78,9 @@ func newService(tokens map[string]string) things.Service {
 	channelsRepo := mocks.NewChannelRepository(thingsRepo, conns)
 	chanCache := mocks.NewChannelCache()
 	thingCache := mocks.NewThingCache()
-	idp := mocks.NewIdentityProvider()
+	uuidProvider := uuid.NewMock()
 
-	return things.New(auth, thingsRepo, channelsRepo, chanCache, thingCache, idp)
+	return things.New(auth, thingsRepo, channelsRepo, chanCache, thingCache, uuidProvider)
 }
 
 func newServer(svc things.Service) *httptest.Server {

things/idp.go

@@ -1,10 +0,0 @@
-// Copyright (c) Mainflux
-// SPDX-License-Identifier: Apache-2.0
-
-package things
-
-// IdentityProvider specifies an API for generating unique identifiers.
-type IdentityProvider interface {
-	// ID generates the unique identifier.
-	ID() (string, error)
-}

things/mocks/idp.go

@@ -1,32 +0,0 @@
-// Copyright (c) Mainflux
-// SPDX-License-Identifier: Apache-2.0
-
-package mocks
-
-import (
-	"fmt"
-	"sync"
-
-	"github.com/mainflux/mainflux/things"
-)
-
-var _ things.IdentityProvider = (*identityProviderMock)(nil)
-
-type identityProviderMock struct {
-	mu      sync.Mutex
-	counter int
-}
-
-func (idp *identityProviderMock) ID() (string, error) {
-	idp.mu.Lock()
-	defer idp.mu.Unlock()
-
-	idp.counter++
-	return fmt.Sprintf("%s%012d", "123e4567-e89b-12d3-a456-", idp.counter), nil
-}
-
-// NewIdentityProvider creates "mirror" identity provider, i.e. generated
-// token will hold value provided by the caller.
-func NewIdentityProvider() things.IdentityProvider {
-	return &identityProviderMock{}
-}

things/postgres/channels.go

@@ -383,7 +383,6 @@ func (m *dbMetadata) Scan(value interface{}) error {
 	}
 
 	if err := json.Unmarshal(b, m); err != nil {
-		m = &dbMetadata{}
 		return err
 	}
 

things/postgres/channels_test.go

@@ -12,7 +12,7 @@ import (
 
 	"github.com/mainflux/mainflux/things"
 	"github.com/mainflux/mainflux/things/postgres"
-	"github.com/mainflux/mainflux/things/uuid"
+	uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/stretchr/testify/assert"
 )
 
@@ -25,7 +25,7 @@ func TestChannelsSave(t *testing.T) {
 	var chid string
 	chs := []things.Channel{}
 	for i := 1; i <= 5; i++ {
-		chid, err := uuid.New().ID()
+		chid, err := uuidProvider.New().ID()
 		require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 		ch := things.Channel{
@@ -95,7 +95,7 @@ func TestChannelUpdate(t *testing.T) {
 	dbMiddleware := postgres.NewDatabase(db)
 	chanRepo := postgres.NewChannelRepository(dbMiddleware)
 
-	cid, err := uuid.New().ID()
+	cid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 	ch := things.Channel{
 		ID:    cid,
@@ -105,7 +105,7 @@ func TestChannelUpdate(t *testing.T) {
 	schs, _ := chanRepo.Save(context.Background(), ch)
 	ch.ID = schs[0].ID
 
-	nonexistentChanID, err := uuid.New().ID()
+	nonexistentChanID, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	cases := []struct {
@@ -156,10 +156,10 @@ func TestSingleChannelRetrieval(t *testing.T) {
 	chanRepo := postgres.NewChannelRepository(dbMiddleware)
 	thingRepo := postgres.NewThingRepository(dbMiddleware)
 
-	thid, err := uuid.New().ID()
+	thid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
-	thkey, err := uuid.New().ID()
+	thkey, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	th := things.Thing{
@@ -170,7 +170,7 @@ func TestSingleChannelRetrieval(t *testing.T) {
 	sths, _ := thingRepo.Save(context.Background(), th)
 	th.ID = sths[0].ID
 
-	chid, err := uuid.New().ID()
+	chid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 	ch := things.Channel{
 		ID:    chid,
@@ -181,7 +181,7 @@ func TestSingleChannelRetrieval(t *testing.T) {
 	ch.ID = schs[0].ID
 	chanRepo.Connect(context.Background(), email, []string{ch.ID}, []string{th.ID})
 
-	nonexistentChanID, err := uuid.New().ID()
+	nonexistentChanID, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	cases := map[string]struct {
@@ -237,7 +237,7 @@ func TestMultiChannelRetrieval(t *testing.T) {
 
 	n := uint64(10)
 	for i := uint64(0); i < n; i++ {
-		chid, err := uuid.New().ID()
+		chid, err := uuidProvider.New().ID()
 		require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 		ch := things.Channel{
@@ -345,12 +345,11 @@ func TestMultiChannelRetrieval(t *testing.T) {
 
 func TestMultiChannelRetrievalByThing(t *testing.T) {
 	email := "channel-multi-retrieval-by-thing@example.com"
-	idp := uuid.New()
 	dbMiddleware := postgres.NewDatabase(db)
 	chanRepo := postgres.NewChannelRepository(dbMiddleware)
 	thingRepo := postgres.NewThingRepository(dbMiddleware)
 
-	thid, err := idp.ID()
+	thid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	sths, err := thingRepo.Save(context.Background(), things.Thing{
@@ -362,7 +361,7 @@ func TestMultiChannelRetrievalByThing(t *testing.T) {
 
 	n := uint64(10)
 	for i := uint64(0); i < n; i++ {
-		chid, err := uuid.New().ID()
+		chid, err := uuidProvider.New().ID()
 		require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 		ch := things.Channel{
 			ID:    chid,
@@ -375,7 +374,7 @@ func TestMultiChannelRetrievalByThing(t *testing.T) {
 		require.Nil(t, err, fmt.Sprintf("unexpected error: %s", err))
 	}
 
-	nonexistentThingID, err := uuid.New().ID()
+	nonexistentThingID, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	cases := map[string]struct {
@@ -437,7 +436,7 @@ func TestChannelRemoval(t *testing.T) {
 	dbMiddleware := postgres.NewDatabase(db)
 	chanRepo := postgres.NewChannelRepository(dbMiddleware)
 
-	chid, err := uuid.New().ID()
+	chid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 	schs, _ := chanRepo.Save(context.Background(), things.Channel{
 		ID:    chid,
@@ -461,9 +460,9 @@ func TestConnect(t *testing.T) {
 	dbMiddleware := postgres.NewDatabase(db)
 	thingRepo := postgres.NewThingRepository(dbMiddleware)
 
-	thid, err := uuid.New().ID()
+	thid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-	thkey, err := uuid.New().ID()
+	thkey, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	thing := things.Thing{
@@ -477,7 +476,7 @@ func TestConnect(t *testing.T) {
 
 	chanRepo := postgres.NewChannelRepository(dbMiddleware)
 
-	chid, err := uuid.New().ID()
+	chid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 	schs, _ := chanRepo.Save(context.Background(), things.Channel{
 		ID:    chid,
@@ -485,10 +484,10 @@ func TestConnect(t *testing.T) {
 	})
 	chanID := schs[0].ID
 
-	nonexistentThingID, err := uuid.New().ID()
+	nonexistentThingID, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
-	nonexistentChanID, err := uuid.New().ID()
+	nonexistentChanID, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	cases := []struct {
@@ -546,9 +545,9 @@ func TestDisconnect(t *testing.T) {
 	dbMiddleware := postgres.NewDatabase(db)
 	thingRepo := postgres.NewThingRepository(dbMiddleware)
 
-	thid, err := uuid.New().ID()
+	thid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-	thkey, err := uuid.New().ID()
+	thkey, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	thing := things.Thing{
@@ -561,7 +560,7 @@ func TestDisconnect(t *testing.T) {
 	thingID := sths[0].ID
 
 	chanRepo := postgres.NewChannelRepository(dbMiddleware)
-	chid, err := uuid.New().ID()
+	chid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 	schs, _ := chanRepo.Save(context.Background(), things.Channel{
 		ID:    chid,
@@ -570,10 +569,10 @@ func TestDisconnect(t *testing.T) {
 	chanID := schs[0].ID
 	chanRepo.Connect(context.Background(), email, []string{chanID}, []string{thingID})
 
-	nonexistentThingID, err := uuid.New().ID()
+	nonexistentThingID, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
-	nonexistentChanID, err := uuid.New().ID()
+	nonexistentChanID, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	cases := []struct {
@@ -631,9 +630,9 @@ func TestHasThing(t *testing.T) {
 	dbMiddleware := postgres.NewDatabase(db)
 	thingRepo := postgres.NewThingRepository(dbMiddleware)
 
-	thid, err := uuid.New().ID()
+	thid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-	thkey, err := uuid.New().ID()
+	thkey, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	thing := things.Thing{
@@ -645,7 +644,7 @@ func TestHasThing(t *testing.T) {
 	thingID := sths[0].ID
 
 	chanRepo := postgres.NewChannelRepository(dbMiddleware)
-	chid, err := uuid.New().ID()
+	chid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 	schs, _ := chanRepo.Save(context.Background(), things.Channel{
 		ID:    chid,
@@ -654,7 +653,7 @@ func TestHasThing(t *testing.T) {
 	chanID := schs[0].ID
 	chanRepo.Connect(context.Background(), email, []string{chanID}, []string{thingID})
 
-	nonexistentChanID, err := uuid.New().ID()
+	nonexistentChanID, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	cases := map[string]struct {
@@ -691,9 +690,9 @@ func TestHasThingByID(t *testing.T) {
 	dbMiddleware := postgres.NewDatabase(db)
 	thingRepo := postgres.NewThingRepository(dbMiddleware)
 
-	thid, err := uuid.New().ID()
+	thid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-	thkey, err := uuid.New().ID()
+	thkey, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	thing := things.Thing{
@@ -704,9 +703,9 @@ func TestHasThingByID(t *testing.T) {
 	sths, _ := thingRepo.Save(context.Background(), thing)
 	thingID := sths[0].ID
 
-	disconnectedThID, err := uuid.New().ID()
+	disconnectedThID, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-	disconnectedThKey, err := uuid.New().ID()
+	disconnectedThKey, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	disconnectedThing := things.Thing{
@@ -718,7 +717,7 @@ func TestHasThingByID(t *testing.T) {
 	disconnectedThingID := sths[0].ID
 
 	chanRepo := postgres.NewChannelRepository(dbMiddleware)
-	chid, err := uuid.New().ID()
+	chid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 	schs, _ := chanRepo.Save(context.Background(), things.Channel{
 		ID:    chid,
@@ -727,7 +726,7 @@ func TestHasThingByID(t *testing.T) {
 	chanID := schs[0].ID
 	chanRepo.Connect(context.Background(), email, []string{chanID}, []string{thingID})
 
-	nonexistentChanID, err := uuid.New().ID()
+	nonexistentChanID, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	cases := map[string]struct {

things/postgres/things_test.go

@@ -12,7 +12,7 @@ import (
 	"github.com/mainflux/mainflux/pkg/errors"
 	"github.com/mainflux/mainflux/things"
 	"github.com/mainflux/mainflux/things/postgres"
-	"github.com/mainflux/mainflux/things/uuid"
+	uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )
@@ -27,16 +27,16 @@ func TestThingsSave(t *testing.T) {
 
 	email := "thing-save@example.com"
 
-	nonexistentThingKey, err := uuid.New().ID()
+	nonexistentThingKey, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	var thid string
 	var thkey string
 	ths := []things.Thing{}
 	for i := 1; i <= 5; i++ {
-		thid, err = uuid.New().ID()
+		thid, err = uuidProvider.New().ID()
 		require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-		thkey, err = uuid.New().ID()
+		thkey, err = uuidProvider.New().ID()
 		require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 		thing := things.Thing{
@@ -116,9 +116,9 @@ func TestThingUpdate(t *testing.T) {
 	email := "thing-update@example.com"
 	validName := "mfx_device"
 
-	thid, err := uuid.New().ID()
+	thid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-	thkey, err := uuid.New().ID()
+	thkey, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	thing := things.Thing{
@@ -130,7 +130,7 @@ func TestThingUpdate(t *testing.T) {
 	sths, _ := thingRepo.Save(context.Background(), thing)
 	thing.ID = sths[0].ID
 
-	nonexistentThingID, err := uuid.New().ID()
+	nonexistentThingID, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	cases := []struct {
@@ -201,9 +201,9 @@ func TestUpdateKey(t *testing.T) {
 	dbMiddleware := postgres.NewDatabase(db)
 	thingRepo := postgres.NewThingRepository(dbMiddleware)
 
-	ethid, err := uuid.New().ID()
+	ethid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-	ethkey, err := uuid.New().ID()
+	ethkey, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	existingThing := things.Thing{
@@ -214,9 +214,9 @@ func TestUpdateKey(t *testing.T) {
 	sths, _ := thingRepo.Save(context.Background(), existingThing)
 	existingThing.ID = sths[0].ID
 
-	thid, err := uuid.New().ID()
+	thid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-	thkey, err := uuid.New().ID()
+	thkey, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	thing := things.Thing{
@@ -228,7 +228,7 @@ func TestUpdateKey(t *testing.T) {
 	sths, _ = thingRepo.Save(context.Background(), thing)
 	thing.ID = sths[0].ID
 
-	nonexistentThingID, err := uuid.New().ID()
+	nonexistentThingID, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	cases := []struct {
@@ -286,9 +286,9 @@ func TestSingleThingRetrieval(t *testing.T) {
 	dbMiddleware := postgres.NewDatabase(db)
 	thingRepo := postgres.NewThingRepository(dbMiddleware)
 
-	thid, err := uuid.New().ID()
+	thid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-	thkey, err := uuid.New().ID()
+	thkey, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	thing := things.Thing{
@@ -300,7 +300,7 @@ func TestSingleThingRetrieval(t *testing.T) {
 	sths, _ := thingRepo.Save(context.Background(), thing)
 	thing.ID = sths[0].ID
 
-	nonexistentThingID, err := uuid.New().ID()
+	nonexistentThingID, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	cases := map[string]struct {
@@ -341,9 +341,9 @@ func TestThingRetrieveByKey(t *testing.T) {
 	dbMiddleware := postgres.NewDatabase(db)
 	thingRepo := postgres.NewThingRepository(dbMiddleware)
 
-	thid, err := uuid.New().ID()
+	thid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-	thkey, err := uuid.New().ID()
+	thkey, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	thing := things.Thing{
@@ -392,7 +392,7 @@ func TestMultiThingRetrieval(t *testing.T) {
 		"wrong": "wrong",
 	}
 
-	idp := uuid.New()
+	up := uuidProvider.New()
 	offset := uint64(1)
 	thNameNum := uint64(3)
 	thMetaNum := uint64(3)
@@ -400,9 +400,9 @@ func TestMultiThingRetrieval(t *testing.T) {
 
 	n := uint64(10)
 	for i := uint64(0); i < n; i++ {
-		thid, err := idp.ID()
+		thid, err := up.ID()
 		require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-		thkey, err := idp.ID()
+		thkey, err := up.ID()
 		require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 		th := things.Thing{
@@ -512,14 +512,14 @@ func TestMultiThingRetrieval(t *testing.T) {
 
 func TestMultiThingRetrievalByChannel(t *testing.T) {
 	email := "thing-multi-retrieval-by-channel@example.com"
-	idp := uuid.New()
+	up := uuidProvider.New()
 	dbMiddleware := postgres.NewDatabase(db)
 	thingRepo := postgres.NewThingRepository(dbMiddleware)
 	channelRepo := postgres.NewChannelRepository(dbMiddleware)
 
 	n := uint64(10)
 
-	chid, err := idp.ID()
+	chid, err := up.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	schs, err := channelRepo.Save(context.Background(), things.Channel{
@@ -529,9 +529,9 @@ func TestMultiThingRetrievalByChannel(t *testing.T) {
 	require.Nil(t, err, fmt.Sprintf("unexpected error: %s", err))
 	cid := schs[0].ID
 	for i := uint64(0); i < n; i++ {
-		thid, err := idp.ID()
+		thid, err := up.ID()
 		require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-		thkey, err := idp.ID()
+		thkey, err := up.ID()
 		require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 		th := things.Thing{
 			ID:    thid,
@@ -546,7 +546,7 @@ func TestMultiThingRetrievalByChannel(t *testing.T) {
 		require.Nil(t, err, fmt.Sprintf("unexpected error: %s", err))
 	}
 
-	nonexistentChanID, err := idp.ID()
+	nonexistentChanID, err := up.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	cases := map[string]struct {
@@ -608,9 +608,9 @@ func TestThingRemoval(t *testing.T) {
 	dbMiddleware := postgres.NewDatabase(db)
 	thingRepo := postgres.NewThingRepository(dbMiddleware)
 
-	thid, err := uuid.New().ID()
+	thid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
-	thkey, err := uuid.New().ID()
+	thkey, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	thing := things.Thing{

things/redis/streams_test.go

@@ -13,6 +13,7 @@ import (
 
 	r "github.com/go-redis/redis"
 	"github.com/mainflux/mainflux/pkg/errors"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/mainflux/mainflux/things"
 	"github.com/mainflux/mainflux/things/mocks"
 	"github.com/mainflux/mainflux/things/redis"
@@ -44,9 +45,9 @@ func newService(tokens map[string]string) things.Service {
 	channelsRepo := mocks.NewChannelRepository(thingsRepo, conns)
 	chanCache := mocks.NewChannelCache()
 	thingCache := mocks.NewThingCache()
-	idp := mocks.NewIdentityProvider()
+	uuidProvider := uuid.NewMock()
 
-	return things.New(auth, thingsRepo, channelsRepo, chanCache, thingCache, idp)
+	return things.New(auth, thingsRepo, channelsRepo, chanCache, thingCache, uuidProvider)
 }
 
 func TestCreateThings(t *testing.T) {

things/redis/things_test.go

@@ -11,7 +11,7 @@ import (
 	r "github.com/go-redis/redis"
 	"github.com/mainflux/mainflux/pkg/errors"
 	"github.com/mainflux/mainflux/things/redis"
-	"github.com/mainflux/mainflux/things/uuid"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 )

things/service.go

@@ -135,18 +135,18 @@ type thingsService struct {
 	channels     ChannelRepository
 	channelCache ChannelCache
 	thingCache   ThingCache
-	idp          IdentityProvider
+	uuidProvider mainflux.UUIDProvider
 }
 
 // New instantiates the things service implementation.
-func New(auth mainflux.AuthNServiceClient, things ThingRepository, channels ChannelRepository, ccache ChannelCache, tcache ThingCache, idp IdentityProvider) Service {
+func New(auth mainflux.AuthNServiceClient, things ThingRepository, channels ChannelRepository, ccache ChannelCache, tcache ThingCache, up mainflux.UUIDProvider) Service {
 	return &thingsService{
 		auth:         auth,
 		things:       things,
 		channels:     channels,
 		channelCache: ccache,
 		thingCache:   tcache,
-		idp:          idp,
+		uuidProvider: up,
 	}
 }
 
@@ -157,7 +157,7 @@ func (ts *thingsService) CreateThings(ctx context.Context, token string, things
 	}
 
 	for i := range things {
-		things[i].ID, err = ts.idp.ID()
+		things[i].ID, err = ts.uuidProvider.ID()
 		if err != nil {
 			return []Thing{}, errors.Wrap(ErrCreateThings, err)
 		}
@@ -165,7 +165,7 @@ func (ts *thingsService) CreateThings(ctx context.Context, token string, things
 		things[i].Owner = res.GetValue()
 
 		if things[i].Key == "" {
-			things[i].Key, err = ts.idp.ID()
+			things[i].Key, err = ts.uuidProvider.ID()
 			if err != nil {
 				return []Thing{}, errors.Wrap(ErrCreateThings, err)
 			}
@@ -246,7 +246,7 @@ func (ts *thingsService) CreateChannels(ctx context.Context, token string, chann
 	}
 
 	for i := range channels {
-		channels[i].ID, err = ts.idp.ID()
+		channels[i].ID, err = ts.uuidProvider.ID()
 		if err != nil {
 			return []Channel{}, errors.Wrap(ErrCreateChannels, err)
 		}

things/service_test.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	"github.com/mainflux/mainflux/pkg/errors"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/mainflux/mainflux/things"
 	"github.com/mainflux/mainflux/things/mocks"
 	"github.com/stretchr/testify/assert"
@@ -35,9 +36,9 @@ func newService(tokens map[string]string) things.Service {
 	channelsRepo := mocks.NewChannelRepository(thingsRepo, conns)
 	chanCache := mocks.NewChannelCache()
 	thingCache := mocks.NewThingCache()
-	idp := mocks.NewIdentityProvider()
+	uuidProvider := uuid.NewMock()
 
-	return things.New(auth, thingsRepo, channelsRepo, chanCache, thingCache, idp)
+	return things.New(auth, thingsRepo, channelsRepo, chanCache, thingCache, uuidProvider)
 }
 
 func TestCreateThings(t *testing.T) {

twins/api/http/endpoint_twins_test.go

@@ -14,10 +14,10 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/mainflux/mainflux/twins"
 	httpapi "github.com/mainflux/mainflux/twins/api/http"
 	"github.com/mainflux/mainflux/twins/mocks"
-
 	"github.com/opentracing/opentracing-go/mocktracer"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -84,6 +84,16 @@ func (tr testRequest) make() (*http.Response, error) {
 	return tr.client.Do(req)
 }
 
+func newService(tokens map[string]string) twins.Service {
+	auth := mocks.NewAuthNServiceClient(tokens)
+	twinsRepo := mocks.NewTwinRepository()
+	statesRepo := mocks.NewStateRepository()
+	subs := map[string]string{"chanID": "chanID"}
+	broker := mocks.NewBroker(subs)
+	uuidProvider := uuid.NewMock()
+	return twins.New(broker, auth, twinsRepo, statesRepo, uuidProvider, "chanID", nil)
+}
+
 func newServer(svc twins.Service) *httptest.Server {
 	mux := httpapi.MakeHandler(mocktracer.New(), svc)
 	return httptest.NewServer(mux)

twins/idp.go

@@ -1,13 +0,0 @@
-// Copyright (c) Mainflux
-// SPDX-License-Identifier: Apache-2.0
-
-package twins
-
-// IdentityProvider specifies an API for generating unique identifiers.
-type IdentityProvider interface {
-	// ID generates the unique identifier.
-	ID() (string, error)
-
-	// IsValid checks whether string is a valid uuid4.
-	IsValid(u4 string) error
-}

twins/mocks/idp.go

@@ -1,43 +0,0 @@
-// Copyright (c) Mainflux
-// SPDX-License-Identifier: Apache-2.0
-
-package mocks
-
-import (
-	"fmt"
-	"strings"
-	"sync"
-
-	"github.com/mainflux/mainflux/twins"
-)
-
-const u4Pref = "123e4567-e89b-12d3-a456-"
-
-var _ twins.IdentityProvider = (*identityProviderMock)(nil)
-
-type identityProviderMock struct {
-	mu      sync.Mutex
-	counter int
-}
-
-func (idp *identityProviderMock) ID() (string, error) {
-	idp.mu.Lock()
-	defer idp.mu.Unlock()
-
-	idp.counter++
-	return fmt.Sprintf("%s%012d", u4Pref, idp.counter), nil
-}
-
-func (idp *identityProviderMock) IsValid(u4 string) error {
-	if !strings.Contains(u4Pref, u4) {
-		return twins.ErrMalformedEntity
-	}
-
-	return nil
-}
-
-// NewIdentityProvider creates "mirror" identity provider, i.e. generated
-// token will hold value provided by the caller.
-func NewIdentityProvider() twins.IdentityProvider {
-	return &identityProviderMock{}
-}

twins/mocks/service.go

@@ -5,8 +5,8 @@ import (
 	"time"
 
 	"github.com/mainflux/mainflux/pkg/messaging"
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/mainflux/mainflux/twins"
-	"github.com/mainflux/mainflux/twins/uuid"
 	"github.com/mainflux/senml"
 )
 
@@ -19,10 +19,10 @@ func NewService(tokens map[string]string) twins.Service {
 	auth := NewAuthNServiceClient(tokens)
 	twinsRepo := NewTwinRepository()
 	statesRepo := NewStateRepository()
-	idp := NewIdentityProvider()
+	uuidProvider := uuid.NewMock()
 	subs := map[string]string{"chanID": "chanID"}
 	broker := NewBroker(subs)
-	return twins.New(broker, auth, twinsRepo, statesRepo, idp, "chanID", nil)
+	return twins.New(broker, auth, twinsRepo, statesRepo, uuidProvider, "chanID", nil)
 }
 
 // CreateDefinition creates twin definition

twins/mocks/twins.go

@@ -10,6 +10,7 @@ import (
 	"strings"
 	"sync"
 
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/mainflux/mainflux/twins"
 )
 
@@ -107,7 +108,7 @@ func (trm *twinRepositoryMock) RetrieveAll(_ context.Context, owner string, offs
 		if !strings.HasPrefix(k, owner) {
 			continue
 		}
-		suffix := string(v.ID[len(u4Pref):])
+		suffix := string(v.ID[len(uuid.Prefix):])
 		id, _ := strconv.ParseUint(suffix, 10, 64)
 		if id > offset && id <= offset+limit {
 			items = append(items, v)

twins/mongodb/states_test.go

@@ -11,7 +11,7 @@ import (
 
 	"github.com/mainflux/mainflux/twins"
 	"github.com/mainflux/mainflux/twins/mongodb"
-	"github.com/mainflux/mainflux/twins/uuid"
+	uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.mongodb.org/mongo-driver/bson"
@@ -26,7 +26,7 @@ func TestStateSave(t *testing.T) {
 	db := client.Database(testDB)
 	repo := mongodb.NewStateRepository(db)
 
-	twid, err := idp.ID()
+	twid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	var id int64
@@ -55,8 +55,6 @@ func TestStateSave(t *testing.T) {
 }
 
 func TestStatesRetrieveAll(t *testing.T) {
-	idp := uuid.New()
-
 	client, err := mongo.Connect(context.Background(), options.Client().ApplyURI(addr))
 	require.Nil(t, err, fmt.Sprintf("Creating new MongoDB client expected to succeed: %s.\n", err))
 
@@ -65,7 +63,7 @@ func TestStatesRetrieveAll(t *testing.T) {
 
 	repo := mongodb.NewStateRepository(db)
 
-	twid, err := idp.ID()
+	twid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	n := uint64(10)
@@ -119,8 +117,6 @@ func TestStatesRetrieveAll(t *testing.T) {
 }
 
 func TestStatesRetrieveLast(t *testing.T) {
-	idp := uuid.New()
-
 	client, err := mongo.Connect(context.Background(), options.Client().ApplyURI(addr))
 	require.Nil(t, err, fmt.Sprintf("Creating new MongoDB client expected to succeed: %s.\n", err))
 
@@ -129,7 +125,7 @@ func TestStatesRetrieveLast(t *testing.T) {
 
 	repo := mongodb.NewStateRepository(db)
 
-	twid, err := idp.ID()
+	twid, err := uuidProvider.New().ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	n := int64(10)

twins/mongodb/twins_test.go

@@ -13,7 +13,7 @@ import (
 	log "github.com/mainflux/mainflux/logger"
 	"github.com/mainflux/mainflux/twins"
 	"github.com/mainflux/mainflux/twins/mongodb"
-	"github.com/mainflux/mainflux/twins/uuid"
+	uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"go.mongodb.org/mongo-driver/bson"
@@ -34,7 +34,7 @@ var (
 	port        string
 	addr        string
 	testLog, _  = log.New(os.Stdout, log.Info.String())
-	idp         = uuid.New()
+	uuid        = uuidProvider.New()
 	db          mongo.Database
 	invalidName = strings.Repeat("m", maxNameSize+1)
 )
@@ -46,10 +46,10 @@ func TestTwinsSave(t *testing.T) {
 	db := client.Database(testDB)
 	repo := mongodb.NewTwinRepository(db)
 
-	twid, err := idp.ID()
+	twid, err := uuid.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
-	nonexistentTwinID, err := idp.ID()
+	nonexistentTwinID, err := uuid.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	twin := twins.Twin{
@@ -91,10 +91,10 @@ func TestTwinsUpdate(t *testing.T) {
 	db := client.Database(testDB)
 	repo := mongodb.NewTwinRepository(db)
 
-	twid, err := idp.ID()
+	twid, err := uuid.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
-	nonexistentTwinID, err := idp.ID()
+	nonexistentTwinID, err := uuid.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	twin := twins.Twin{
@@ -148,10 +148,10 @@ func TestTwinsRetrieveByID(t *testing.T) {
 	db := client.Database(testDB)
 	repo := mongodb.NewTwinRepository(db)
 
-	twid, err := idp.ID()
+	twid, err := uuid.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
-	nonexistentTwinID, err := idp.ID()
+	nonexistentTwinID, err := uuid.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	twin := twins.Twin{
@@ -194,7 +194,6 @@ func TestTwinsRetrieveAll(t *testing.T) {
 	wrongMetadata := twins.Metadata{
 		"wrong": "wrong",
 	}
-	idp := uuid.New()
 
 	client, err := mongo.Connect(context.Background(), options.Client().ApplyURI(addr))
 	require.Nil(t, err, fmt.Sprintf("Creating new MongoDB client expected to succeed: %s.\n", err))
@@ -206,7 +205,7 @@ func TestTwinsRetrieveAll(t *testing.T) {
 
 	n := uint64(10)
 	for i := uint64(0); i < n; i++ {
-		twid, err := idp.ID()
+		twid, err := uuidProvider.New().ID()
 		require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 		tw := twins.Twin{
@@ -299,10 +298,10 @@ func TestTwinsRemove(t *testing.T) {
 	db := client.Database(testDB)
 	repo := mongodb.NewTwinRepository(db)
 
-	twid, err := idp.ID()
+	twid, err := uuid.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
-	nonexistentTwinID, err := idp.ID()
+	nonexistentTwinID, err := uuid.ID()
 	require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
 
 	twin := twins.Twin{

twins/service.go

@@ -90,27 +90,27 @@ var crudOp = map[string]string{
 }
 
 type twinsService struct {
-	publisher messaging.Publisher
-	auth      mainflux.AuthNServiceClient
-	twins     TwinRepository
-	states    StateRepository
-	idp       IdentityProvider
-	channelID string
-	logger    logger.Logger
+	publisher    messaging.Publisher
+	auth         mainflux.AuthNServiceClient
+	twins        TwinRepository
+	states       StateRepository
+	uuidProvider mainflux.UUIDProvider
+	channelID    string
+	logger       logger.Logger
 }
 
 var _ Service = (*twinsService)(nil)
 
 // New instantiates the twins service implementation.
-func New(publisher messaging.Publisher, auth mainflux.AuthNServiceClient, twins TwinRepository, sr StateRepository, idp IdentityProvider, chann string, logger logger.Logger) Service {
+func New(publisher messaging.Publisher, auth mainflux.AuthNServiceClient, twins TwinRepository, sr StateRepository, up mainflux.UUIDProvider, chann string, logger logger.Logger) Service {
 	return &twinsService{
-		publisher: publisher,
-		auth:      auth,
-		twins:     twins,
-		states:    sr,
-		idp:       idp,
-		channelID: chann,
-		logger:    logger,
+		publisher:    publisher,
+		auth:         auth,
+		twins:        twins,
+		states:       sr,
+		uuidProvider: up,
+		channelID:    chann,
+		logger:       logger,
 	}
 }
 
@@ -124,7 +124,7 @@ func (ts *twinsService) AddTwin(ctx context.Context, token string, twin Twin, de
 		return Twin{}, ErrUnauthorizedAccess
 	}
 
-	twin.ID, err = ts.idp.ID()
+	twin.ID, err = ts.uuidProvider.ID()
 	if err != nil {
 		return Twin{}, err
 	}

twins/service_test.go

@@ -8,6 +8,7 @@ import (
 	"fmt"
 	"testing"
 
+	"github.com/mainflux/mainflux/pkg/uuid"
 	"github.com/mainflux/mainflux/twins"
 	"github.com/mainflux/mainflux/twins/mocks"
 	"github.com/mainflux/senml"
@@ -16,13 +17,12 @@ import (
 )
 
 const (
-	twinName   = "name"
-	wrongID    = ""
-	token      = "token"
-	wrongToken = "wrong-token"
-	email      = "user@example.com"
-	natsURL    = "nats://localhost:4222"
-
+	twinName      = "name"
+	wrongID       = ""
+	token         = "token"
+	wrongToken    = "wrong-token"
+	email         = "user@example.com"
+	natsURL       = "nats://localhost:4222"
 	attrName1     = "temperature"
 	attrSubtopic1 = "engine"
 	attrName2     = "humidity"
@@ -32,6 +32,16 @@ const (
 	numRecs       = 100
 )
 
+func newService(tokens map[string]string) twins.Service {
+	auth := mocks.NewAuthNServiceClient(tokens)
+	twinsRepo := mocks.NewTwinRepository()
+	statesRepo := mocks.NewStateRepository()
+	uuidProvider := uuid.NewMock()
+	subs := map[string]string{"chanID": "chanID"}
+	broker := mocks.NewBroker(subs)
+	return twins.New(broker, auth, twinsRepo, statesRepo, uuidProvider, "chanID", nil)
+}
+
 func TestAddTwin(t *testing.T) {
 	svc := mocks.NewService(map[string]string{token: email})
 	twin := twins.Twin{}

twins/uuid/idp.go

@@ -1,36 +0,0 @@
-// Copyright (c) Mainflux
-// SPDX-License-Identifier: Apache-2.0
-
-// Package uuid provides a UUID identity provider.
-package uuid
-
-import (
-	"github.com/gofrs/uuid"
-	"github.com/mainflux/mainflux/twins"
-)
-
-var _ twins.IdentityProvider = (*uuidIdentityProvider)(nil)
-
-type uuidIdentityProvider struct{}
-
-// New instantiates a UUID identity provider.
-func New() twins.IdentityProvider {
-	return &uuidIdentityProvider{}
-}
-
-func (idp *uuidIdentityProvider) ID() (string, error) {
-	id, err := uuid.NewV4()
-	if err != nil {
-		return "", err
-	}
-
-	return id.String(), nil
-}
-
-func (idp *uuidIdentityProvider) IsValid(u4 string) error {
-	if _, err := uuid.FromString(u4); err != nil {
-		return twins.ErrMalformedEntity
-	}
-
-	return nil
-}

users/tracing/users.go

@@ -14,7 +14,7 @@ import (
 
 const (
 	saveOp             = "save_op"
-	retrieveByIDOp     = "retrieve_by_id"
+	retrieveByEmailOp  = "retrieve_by_email"
 	generateResetToken = "generate_reset_token"
 	updatePassword     = "update_password"
 	sendPasswordReset  = "send_reset_password"
@@ -53,7 +53,7 @@ func (urm userRepositoryMiddleware) UpdateUser(ctx context.Context, user users.U
 }
 
 func (urm userRepositoryMiddleware) RetrieveByID(ctx context.Context, id string) (users.User, error) {
-	span := createSpan(ctx, urm.tracer, retrieveByIDOp)
+	span := createSpan(ctx, urm.tracer, retrieveByEmailOp)
 	defer span.Finish()
 	ctx = opentracing.ContextWithSpan(ctx, span)
 

uuid.go

@@ -1,10 +1,10 @@
 // Copyright (c) Mainflux
 // SPDX-License-Identifier: Apache-2.0
 
-package authn
+package mainflux
 
-// IdentityProvider specifies an API for generating unique identifiers.
-type IdentityProvider interface {
+// UUIDProvider specifies an API for generating unique identifiers.
+type UUIDProvider interface {
 	// ID generates the unique identifier.
 	ID() (string, error)
 }