OrgGo
/
Mainflux.mainflux
mirror of https://github.com/mainflux/mainflux.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

NOISSUE - Rename package aliases uuidProvider into uuid (#1323) 

* NOISSUE - Rename pkg aliases uuidProvider into uuid and fix authn typo

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

* Add missing error checks

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

* Use global uuidProvider

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

* Use expTime globally

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

* Fix user uuid provider

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

* Fix review

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

* Use idProvider name

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

* Use idProvider instead of uuidProvider

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

* Use idProvider instead of uuidProvider

Signed-off-by: Manuel Imperiale <manuel.imperiale@gmail.com>
This commit is contained in:
Manuel Imperiale 2021-01-17 23:12:45 +01:00 committed by GitHub
parent 0516fe2fd7
commit 0f856f5667
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
33 changed files with 260 additions and 231 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
auth/api/grpc/endpoint_test.go
View File

@ -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) {

4
auth/api/http/endpoint_test.go
View File

@ -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 {

32
auth/postgres/key_test.go
View File

@ -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,9 +71,9 @@ 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(),
@ -73,7 +81,7 @@ func TestKeyRetrieve(t *testing.T) {
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,9 +119,9 @@ 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(),
@ -121,7 +129,7 @@ func TestKeyRemove(t *testing.T) {
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

8
auth/service.go
View File

@ -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)
}

4
auth/service_test.go
View File

@ -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) {

7
cmd/auth/main.go
View File

@ -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,

30
cmd/things/main.go
View File

@ -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(

6
cmd/twins/main.go
View File

@ -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,

5
cmd/users/main.go
View File

@ -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,

4
pkg/sdk/go/things_test.go
View File

@ -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 {

4
pkg/sdk/go/users_test.go
View File

@ -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 {

8
readers/cassandra/messages_test.go
View File

@ -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{

11
readers/influxdb/messages_test.go
View File

@ -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{

12
readers/postgres/messages_test.go
View File

@ -10,7 +10,7 @@ import (
pwriter "github.com/mainflux/mainflux/consumers/writers/postgres"
"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"
preader "github.com/mainflux/mainflux/readers/postgres"
"github.com/stretchr/testify/assert"
@ -33,18 +33,20 @@ var (
vb = true
vd = "dataValue"
sum float64 = 42
idProvider = uuid.New()
)
func TestReadSenml(t *testing.T) {
writer := pwriter.New(db)
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))
wrongID, err := uuidProvider.New().ID()
wrongID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
m := senml.Message{

4
things/api/auth/grpc/setup_test.go
View File

@ -48,7 +48,7 @@ func newService(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)
}

4
things/api/auth/http/endpoint_test.go
View File

@ -73,9 +73,9 @@ func newService(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 newServer(svc things.Service) *httptest.Server {

4
things/api/things/http/endpoint_test.go
View File

@ -78,9 +78,9 @@ func newService(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 newServer(svc things.Service) *httptest.Server {

69
things/postgres/channels_test.go
View File

@ -11,7 +11,6 @@ import (
"github.com/stretchr/testify/require"
"github.com/mainflux/mainflux/pkg/errors"
uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
"github.com/mainflux/mainflux/things"
"github.com/mainflux/mainflux/things/postgres"
"github.com/stretchr/testify/assert"
@ -25,7 +24,7 @@ func TestChannelsSave(t *testing.T) {
chs := []things.Channel{}
for i := 1; i <= 5; i++ {
id, err := uuidProvider.New().ID()
id, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
ch := things.Channel{
@ -85,7 +84,7 @@ func TestChannelUpdate(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
chanRepo := postgres.NewChannelRepository(dbMiddleware)
id, err := uuidProvider.New().ID()
id, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
ch := things.Channel{
ID: id,
@ -96,7 +95,7 @@ func TestChannelUpdate(t *testing.T) {
require.Nil(t, err, fmt.Sprintf("unexpected error: %s\n", err))
ch.ID = chs[0].ID
nonexistentChanID, err := uuidProvider.New().ID()
nonexistentChanID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
cases := []struct {
@ -147,9 +146,9 @@ func TestSingleChannelRetrieval(t *testing.T) {
chanRepo := postgres.NewChannelRepository(dbMiddleware)
thingRepo := postgres.NewThingRepository(dbMiddleware)
thid, err := uuidProvider.New().ID()
thid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
thkey, err := uuidProvider.New().ID()
thkey, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
th := things.Thing{
ID: thid,
@ -159,7 +158,7 @@ func TestSingleChannelRetrieval(t *testing.T) {
ths, _ := thingRepo.Save(context.Background(), th)
th.ID = ths[0].ID
chid, err := uuidProvider.New().ID()
chid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
ch := things.Channel{
ID: chid,
@ -169,7 +168,7 @@ func TestSingleChannelRetrieval(t *testing.T) {
ch.ID = chs[0].ID
chanRepo.Connect(context.Background(), email, []string{ch.ID}, []string{th.ID})
nonexistentChanID, err := uuidProvider.New().ID()
nonexistentChanID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
cases := map[string]struct {
@ -225,7 +224,7 @@ func TestMultiChannelRetrieval(t *testing.T) {
n := uint64(10)
for i := uint64(0); i < n; i++ {
chid, err := uuidProvider.New().ID()
chid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
ch := things.Channel{
@ -251,8 +250,8 @@ func TestMultiChannelRetrieval(t *testing.T) {
}
cases := map[string]struct {
owner string
size uint64
owner string
size uint64
pageMetadata things.PageMetadata
}{
"retrieve all channels with existing owner": {
@ -387,7 +386,7 @@ func TestRetrieveByThing(t *testing.T) {
chanRepo := postgres.NewChannelRepository(dbMiddleware)
thingRepo := postgres.NewThingRepository(dbMiddleware)
thid, err := uuidProvider.New().ID()
thid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
ths, err := thingRepo.Save(context.Background(), things.Thing{
ID: thid,
@ -400,7 +399,7 @@ func TestRetrieveByThing(t *testing.T) {
chsDisconNum := uint64(1)
for i := uint64(0); i < n; i++ {
chid, err := uuidProvider.New().ID()
chid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
ch := things.Channel{
ID: chid,
@ -419,7 +418,7 @@ func TestRetrieveByThing(t *testing.T) {
require.Nil(t, err, fmt.Sprintf("unexpected error: %s", err))
}
nonexistentThingID, err := uuidProvider.New().ID()
nonexistentThingID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
cases := map[string]struct {
@ -495,7 +494,7 @@ func TestChannelRemoval(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
chanRepo := postgres.NewChannelRepository(dbMiddleware)
chid, err := uuidProvider.New().ID()
chid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
chs, err := chanRepo.Save(context.Background(), things.Channel{
ID: chid,
@ -520,9 +519,9 @@ func TestConnect(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
thingRepo := postgres.NewThingRepository(dbMiddleware)
thid, err := uuidProvider.New().ID()
thid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
thkey, err := uuidProvider.New().ID()
thkey, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
th := things.Thing{
@ -537,7 +536,7 @@ func TestConnect(t *testing.T) {
chanRepo := postgres.NewChannelRepository(dbMiddleware)
chid, err := uuidProvider.New().ID()
chid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
chs, err := chanRepo.Save(context.Background(), things.Channel{
ID: chid,
@ -546,10 +545,10 @@ func TestConnect(t *testing.T) {
require.Nil(t, err, fmt.Sprintf("unexpected error: %s\n", err))
chid = chs[0].ID
nonexistentThingID, err := uuidProvider.New().ID()
nonexistentThingID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
nonexistentChanID, err := uuidProvider.New().ID()
nonexistentChanID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
cases := []struct {
@ -607,9 +606,9 @@ func TestDisconnect(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
thingRepo := postgres.NewThingRepository(dbMiddleware)
thid, err := uuidProvider.New().ID()
thid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
thkey, err := uuidProvider.New().ID()
thkey, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
th := things.Thing{
ID: thid,
@ -622,7 +621,7 @@ func TestDisconnect(t *testing.T) {
thid = ths[0].ID
chanRepo := postgres.NewChannelRepository(dbMiddleware)
chid, err := uuidProvider.New().ID()
chid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
chs, err := chanRepo.Save(context.Background(), things.Channel{
ID: chid,
@ -632,10 +631,10 @@ func TestDisconnect(t *testing.T) {
chid = chs[0].ID
chanRepo.Connect(context.Background(), email, []string{chid}, []string{thid})
nonexistentThingID, err := uuidProvider.New().ID()
nonexistentThingID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
nonexistentChanID, err := uuidProvider.New().ID()
nonexistentChanID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
cases := []struct {
@ -693,9 +692,9 @@ func TestHasThing(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
thingRepo := postgres.NewThingRepository(dbMiddleware)
thid, err := uuidProvider.New().ID()
thid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
thkey, err := uuidProvider.New().ID()
thkey, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
th := things.Thing{
@ -708,7 +707,7 @@ func TestHasThing(t *testing.T) {
thid = ths[0].ID
chanRepo := postgres.NewChannelRepository(dbMiddleware)
chid, err := uuidProvider.New().ID()
chid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
chs, err := chanRepo.Save(context.Background(), things.Channel{
ID: chid,
@ -718,7 +717,7 @@ func TestHasThing(t *testing.T) {
chid = chs[0].ID
chanRepo.Connect(context.Background(), email, []string{chid}, []string{thid})
nonexistentChanID, err := uuidProvider.New().ID()
nonexistentChanID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
cases := map[string]struct {
@ -755,9 +754,9 @@ func TestHasThingByID(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
thingRepo := postgres.NewThingRepository(dbMiddleware)
thid, err := uuidProvider.New().ID()
thid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
thkey, err := uuidProvider.New().ID()
thkey, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
th := things.Thing{
ID: thid,
@ -768,9 +767,9 @@ func TestHasThingByID(t *testing.T) {
require.Nil(t, err, fmt.Sprintf("unexpected error: %s\n", err))
thid = ths[0].ID
disconnectedThID, err := uuidProvider.New().ID()
disconnectedThID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
disconnectedThKey, err := uuidProvider.New().ID()
disconnectedThKey, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
disconnectedThing := things.Thing{
@ -783,7 +782,7 @@ func TestHasThingByID(t *testing.T) {
disconnectedThingID := ths[0].ID
chanRepo := postgres.NewChannelRepository(dbMiddleware)
chid, err := uuidProvider.New().ID()
chid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
chs, err := chanRepo.Save(context.Background(), things.Channel{
ID: chid,
@ -793,7 +792,7 @@ func TestHasThingByID(t *testing.T) {
chid = chs[0].ID
chanRepo.Connect(context.Background(), email, []string{chid}, []string{thid})
nonexistentChanID, err := uuidProvider.New().ID()
nonexistentChanID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
cases := map[string]struct {

62
things/postgres/things_test.go
View File

@ -10,7 +10,7 @@ import (
"testing"
"github.com/mainflux/mainflux/pkg/errors"
uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
"github.com/mainflux/mainflux/pkg/uuid"
"github.com/mainflux/mainflux/things"
"github.com/mainflux/mainflux/things/postgres"
"github.com/stretchr/testify/assert"
@ -19,7 +19,10 @@ import (
const maxNameSize = 1024
var invalidName = strings.Repeat("m", maxNameSize+1)
var (
invalidName = strings.Repeat("m", maxNameSize+1)
idProvider = uuid.New()
)
func TestThingsSave(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
@ -27,14 +30,14 @@ func TestThingsSave(t *testing.T) {
email := "thing-save@example.com"
nonexistentThingKey, err := uuidProvider.New().ID()
nonexistentThingKey, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
ths := []things.Thing{}
for i := 1; i <= 5; i++ {
thid, err := uuidProvider.New().ID()
thid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
thkey, err := uuidProvider.New().ID()
thkey, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
thing := things.Thing{
@ -103,9 +106,9 @@ func TestThingUpdate(t *testing.T) {
email := "thing-update@example.com"
validName := "mfx_device"
thid, err := uuidProvider.New().ID()
thid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
thkey, err := uuidProvider.New().ID()
thkey, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
thing := things.Thing{
@ -119,7 +122,7 @@ func TestThingUpdate(t *testing.T) {
thing.ID = sths[0].ID
nonexistentThingID, err := uuidProvider.New().ID()
nonexistentThingID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
cases := []struct {
@ -190,9 +193,9 @@ func TestUpdateKey(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
thingRepo := postgres.NewThingRepository(dbMiddleware)
id, err := uuidProvider.New().ID()
id, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
key, err := uuidProvider.New().ID()
key, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
th1 := things.Thing{
ID: id,
@ -203,9 +206,9 @@ func TestUpdateKey(t *testing.T) {
require.Nil(t, err, fmt.Sprintf("unexpected error: %s\n", err))
th1.ID = ths[0].ID
id, err = uuidProvider.New().ID()
id, err = idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
key, err = uuidProvider.New().ID()
key, err = idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
th2 := things.Thing{
ID: id,
@ -216,7 +219,7 @@ func TestUpdateKey(t *testing.T) {
require.Nil(t, err, fmt.Sprintf("unexpected error: %s\n", err))
th2.ID = ths[0].ID
nonexistentThingID, err := uuidProvider.New().ID()
nonexistentThingID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
cases := []struct {
@ -274,9 +277,9 @@ func TestSingleThingRetrieval(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
thingRepo := postgres.NewThingRepository(dbMiddleware)
id, err := uuidProvider.New().ID()
id, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
key, err := uuidProvider.New().ID()
key, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
th := things.Thing{
ID: id,
@ -288,7 +291,7 @@ func TestSingleThingRetrieval(t *testing.T) {
require.Nil(t, err, fmt.Sprintf("unexpected error: %s\n", err))
th.ID = ths[0].ID
nonexistentThingID, err := uuidProvider.New().ID()
nonexistentThingID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
cases := map[string]struct {
@ -329,9 +332,9 @@ func TestThingRetrieveByKey(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
thingRepo := postgres.NewThingRepository(dbMiddleware)
id, err := uuidProvider.New().ID()
id, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
key, err := uuidProvider.New().ID()
key, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
th := things.Thing{
@ -381,7 +384,6 @@ func TestMultiThingRetrieval(t *testing.T) {
"wrong": "wrong",
}
up := uuidProvider.New()
offset := uint64(1)
nameNum := uint64(3)
metaNum := uint64(3)
@ -389,9 +391,9 @@ func TestMultiThingRetrieval(t *testing.T) {
n := uint64(10)
for i := uint64(0); i < n; i++ {
id, err := up.ID()
id, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
key, err := up.ID()
key, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
th := things.Thing{
Owner: email,
@ -418,9 +420,9 @@ func TestMultiThingRetrieval(t *testing.T) {
}
cases := map[string]struct {
owner string
owner string
pageMetadata things.PageMetadata
size uint64
size uint64
}{
"retrieve all things with existing owner": {
owner: email,
@ -551,7 +553,7 @@ func TestMultiThingRetrieval(t *testing.T) {
func TestMultiThingRetrievalByChannel(t *testing.T) {
email := "thing-multi-retrieval-by-channel@example.com"
up := uuidProvider.New()
dbMiddleware := postgres.NewDatabase(db)
thingRepo := postgres.NewThingRepository(dbMiddleware)
channelRepo := postgres.NewChannelRepository(dbMiddleware)
@ -559,7 +561,7 @@ func TestMultiThingRetrievalByChannel(t *testing.T) {
n := uint64(10)
thsDisconNum := uint64(1)
chid, err := up.ID()
chid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
chs, err := channelRepo.Save(context.Background(), things.Channel{
@ -569,9 +571,9 @@ func TestMultiThingRetrievalByChannel(t *testing.T) {
require.Nil(t, err, fmt.Sprintf("unexpected error: %s", err))
cid := chs[0].ID
for i := uint64(0); i < n; i++ {
thid, err := up.ID()
thid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
thkey, err := up.ID()
thkey, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
th := things.Thing{
ID: thid,
@ -592,7 +594,7 @@ func TestMultiThingRetrievalByChannel(t *testing.T) {
require.Nil(t, err, fmt.Sprintf("unexpected error: %s", err))
}
nonexistentChanID, err := up.ID()
nonexistentChanID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
cases := map[string]struct {
@ -668,9 +670,9 @@ func TestThingRemoval(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
thingRepo := postgres.NewThingRepository(dbMiddleware)
id, err := uuidProvider.New().ID()
id, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
key, err := uuidProvider.New().ID()
key, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
thing := things.Thing{
ID: id,

4
things/redis/streams_test.go
View File

@ -45,9 +45,9 @@ func newService(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 TestCreateThings(t *testing.T) {

8
things/redis/things_test.go
View File

@ -16,9 +16,11 @@ import (
"github.com/stretchr/testify/require"
)
var idProvider = uuid.New()
func TestThingSave(t *testing.T) {
thingCache := redis.NewThingCache(redisClient)
key, err := uuid.New().ID()
key, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
id := "123"
id2 := "124"
@ -56,7 +58,7 @@ func TestThingSave(t *testing.T) {
func TestThingID(t *testing.T) {
thingCache := redis.NewThingCache(redisClient)
key, err := uuid.New().ID()
key, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
id := "123"
err = thingCache.Save(context.Background(), key, id)
@ -89,7 +91,7 @@ func TestThingID(t *testing.T) {
func TestThingRemove(t *testing.T) {
thingCache := redis.NewThingCache(redisClient)
key, err := uuid.New().ID()
key, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
id := "123"
id2 := "321"

12
things/service.go
View File

@ -147,12 +147,12 @@ type thingsService struct {
groups groups.Repository
channelCache ChannelCache
thingCache ThingCache
uuidProvider mainflux.IDProvider
idProvider mainflux.IDProvider
ulidProvider mainflux.IDProvider
}
// New instantiates the things service implementation.
func New(auth mainflux.AuthServiceClient, things ThingRepository, channels ChannelRepository, groups groups.Repository, ccache ChannelCache, tcache ThingCache, up mainflux.IDProvider) Service {
func New(auth mainflux.AuthServiceClient, things ThingRepository, channels ChannelRepository, groups groups.Repository, ccache ChannelCache, tcache ThingCache, idp mainflux.IDProvider) Service {
return &thingsService{
auth: auth,
things: things,
@ -160,7 +160,7 @@ func New(auth mainflux.AuthServiceClient, things ThingRepository, channels Chann
channels: channels,
channelCache: ccache,
thingCache: tcache,
uuidProvider: up,
idProvider: idp,
ulidProvider: ulid.New(),
}
}
@ -172,7 +172,7 @@ func (ts *thingsService) CreateThings(ctx context.Context, token string, things
}
for i := range things {
things[i].ID, err = ts.uuidProvider.ID()
things[i].ID, err = ts.idProvider.ID()
if err != nil {
return []Thing{}, errors.Wrap(ErrCreateUUID, err)
}
@ -180,7 +180,7 @@ func (ts *thingsService) CreateThings(ctx context.Context, token string, things
things[i].Owner = res.GetEmail()
if things[i].Key == "" {
things[i].Key, err = ts.uuidProvider.ID()
things[i].Key, err = ts.idProvider.ID()
if err != nil {
return []Thing{}, errors.Wrap(ErrCreateUUID, err)
}
@ -258,7 +258,7 @@ func (ts *thingsService) CreateChannels(ctx context.Context, token string, chann
}
for i := range channels {
channels[i].ID, err = ts.uuidProvider.ID()
channels[i].ID, err = ts.idProvider.ID()
if err != nil {
return []Channel{}, errors.Wrap(ErrCreateUUID, err)
}

16
things/service_test.go
View File

@ -36,9 +36,9 @@ func newService(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 TestCreateThings(t *testing.T) {
@ -200,10 +200,10 @@ func TestListThings(t *testing.T) {
}
cases := map[string]struct {
token string
token string
pageMetadata things.PageMetadata
size uint64
err error
size uint64
err error
}{
"list all things": {
token: token,
@ -559,10 +559,10 @@ func TestListChannels(t *testing.T) {
svc.CreateChannels(context.Background(), token, channel)
}
cases := map[string]struct {
token string
token string
pageMetadata things.PageMetadata
size uint64
err error
size uint64
err error
}{
"list all channels": {
token: token,

5
twins/mocks/service.go
View File

@ -21,10 +21,11 @@ func NewService(tokens map[string]string) twins.Service {
twinsRepo := NewTwinRepository()
twinCache := NewTwinCache()
statesRepo := NewStateRepository()
uuidProvider := uuid.NewMock()
idProvider := uuid.NewMock()
subs := map[string]string{"chanID": "chanID"}
broker := NewBroker(subs)
return twins.New(broker, auth, twinsRepo, twinCache, statesRepo, uuidProvider, "chanID", nil)
return twins.New(broker, auth, twinsRepo, twinCache, statesRepo, idProvider, "chanID", nil)
}
// CreateDefinition creates twin definition

7
twins/mongodb/states_test.go
View File

@ -11,7 +11,6 @@ import (
"github.com/mainflux/mainflux/twins"
"github.com/mainflux/mainflux/twins/mongodb"
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 +25,7 @@ func TestStateSave(t *testing.T) {
db := client.Database(testDB)
repo := mongodb.NewStateRepository(db)
twid, err := uuidProvider.New().ID()
twid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
var id int64
@ -63,7 +62,7 @@ func TestStatesRetrieveAll(t *testing.T) {
repo := mongodb.NewStateRepository(db)
twid, err := uuidProvider.New().ID()
twid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
n := uint64(10)
@ -125,7 +124,7 @@ func TestStatesRetrieveLast(t *testing.T) {
repo := mongodb.NewStateRepository(db)
twid, err := uuidProvider.New().ID()
twid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
n := int64(10)

24
twins/mongodb/twins_test.go
View File

@ -11,7 +11,7 @@ import (
"testing"
log "github.com/mainflux/mainflux/logger"
uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
"github.com/mainflux/mainflux/pkg/uuid"
"github.com/mainflux/mainflux/twins"
"github.com/mainflux/mainflux/twins/mocks"
"github.com/mainflux/mainflux/twins/mongodb"
@ -36,7 +36,7 @@ var (
port string
addr string
testLog, _ = log.New(os.Stdout, log.Info.String())
uuid = uuidProvider.New()
idProvider = uuid.New()
db mongo.Database
invalidName = strings.Repeat("m", maxNameSize+1)
)
@ -48,10 +48,10 @@ func TestTwinsSave(t *testing.T) {
db := client.Database(testDB)
repo := mongodb.NewTwinRepository(db)
twid, err := uuid.ID()
twid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
nonexistentTwinID, err := uuid.ID()
nonexistentTwinID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
twin := twins.Twin{
@ -93,10 +93,10 @@ func TestTwinsUpdate(t *testing.T) {
db := client.Database(testDB)
repo := mongodb.NewTwinRepository(db)
twid, err := uuid.ID()
twid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
nonexistentTwinID, err := uuid.ID()
nonexistentTwinID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
twin := twins.Twin{
@ -150,10 +150,10 @@ func TestTwinsRetrieveByID(t *testing.T) {
db := client.Database(testDB)
repo := mongodb.NewTwinRepository(db)
twid, err := uuid.ID()
twid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
nonexistentTwinID, err := uuid.ID()
nonexistentTwinID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
twin := twins.Twin{
@ -194,7 +194,7 @@ func TestTwinsRetrieveByAttribute(t *testing.T) {
db := client.Database(testDB)
repo := mongodb.NewTwinRepository(db)
chID, err := uuid.ID()
chID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
empty := mocks.CreateTwin([]string{chID}, []string{""})
@ -256,7 +256,7 @@ func TestTwinsRetrieveAll(t *testing.T) {
n := uint64(10)
for i := uint64(0); i < n; i++ {
twid, err := uuidProvider.New().ID()
twid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
tw := twins.Twin{
@ -349,10 +349,10 @@ func TestTwinsRemove(t *testing.T) {
db := client.Database(testDB)
repo := mongodb.NewTwinRepository(db)
twid, err := uuid.ID()
twid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
nonexistentTwinID, err := uuid.ID()
nonexistentTwinID, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
twin := twins.Twin{

34
twins/service.go
View File

@ -89,14 +89,14 @@ var crudOp = map[string]string{
}
type twinsService struct {
publisher messaging.Publisher
auth mainflux.AuthServiceClient
twins TwinRepository
states StateRepository
uuidProvider mainflux.IDProvider
channelID string
twinCache TwinCache
logger logger.Logger
publisher messaging.Publisher
auth mainflux.AuthServiceClient
twins TwinRepository
states StateRepository
idProvider mainflux.IDProvider
channelID string
twinCache TwinCache
logger logger.Logger
}
var _ Service = (*twinsService)(nil)
@ -104,14 +104,14 @@ var _ Service = (*twinsService)(nil)
// New instantiates the twins service implementation.
func New(publisher messaging.Publisher, auth mainflux.AuthServiceClient, twins TwinRepository, tcache TwinCache, sr StateRepository, idp mainflux.IDProvider, chann string, logger logger.Logger) Service {
return &twinsService{
publisher: publisher,
auth: auth,
twins: twins,
twinCache: tcache,
states: sr,
uuidProvider: idp,
channelID: chann,
logger: logger,
publisher: publisher,
auth: auth,
twins: twins,
twinCache: tcache,
states: sr,
idProvider: idp,
channelID: chann,
logger: logger,
}
}
@ -125,7 +125,7 @@ func (ts *twinsService) AddTwin(ctx context.Context, token string, twin Twin, de
return Twin{}, ErrUnauthorizedAccess
}
twin.ID, err = ts.uuidProvider.ID()
twin.ID, err = ts.idProvider.ID()
if err != nil {
return Twin{}, err
}

4
users/api/endpoint_test.go
View File

@ -15,6 +15,7 @@ import (
"testing"
"github.com/mainflux/mainflux"
"github.com/mainflux/mainflux/pkg/uuid"
"github.com/mainflux/mainflux/users"
"github.com/mainflux/mainflux/users/api"
"github.com/mainflux/mainflux/users/bcrypt"
@ -70,8 +71,9 @@ func newService() users.Service {
hasher := bcrypt.New()
auth := mocks.NewAuthService(map[string]string{user.Email: user.Email})
email := mocks.NewEmailer()
idProvider := uuid.New()
return users.New(usersRepo, groupRepo, hasher, auth, email)
return users.New(usersRepo, groupRepo, hasher, auth, email, idProvider)
}
func newServer(svc users.Service) *httptest.Server {

42
users/postgres/groups_test.go
View File

@ -10,8 +10,6 @@ import (
"testing"
"github.com/mainflux/mainflux/pkg/errors"
"github.com/mainflux/mainflux/pkg/uuid"
uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
"github.com/mainflux/mainflux/users"
"github.com/mainflux/mainflux/users/postgres"
"github.com/stretchr/testify/assert"
@ -25,14 +23,16 @@ const (
password = "12345678"
)
var invalidName = strings.Repeat("m", maxNameSize+1)
var invalidDesc = strings.Repeat("m", maxDescSize+1)
var (
invalidName = strings.Repeat("m", maxNameSize+1)
invalidDesc = strings.Repeat("m", maxDescSize+1)
)
func TestGroupSave(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
repo := postgres.NewGroupRepo(dbMiddleware)
userRepo := postgres.NewUserRepo(dbMiddleware)
uid, err := uuid.New().ID()
uid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("user id unexpected error: %s", err))
user := users.User{
ID: uid,
@ -45,7 +45,7 @@ func TestGroupSave(t *testing.T) {
user, err = userRepo.RetrieveByEmail(context.Background(), user.Email)
require.Nil(t, err, fmt.Sprintf("retrieve got unexpected error: %s", err))
uid, err = uuid.New().ID()
uid, err = idProvider.ID()
require.Nil(t, err, fmt.Sprintf("group id unexpected error: %s", err))
group := users.Group{
ID: uid,
@ -87,7 +87,7 @@ func TestGroupRetrieveByID(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
repo := postgres.NewGroupRepo(dbMiddleware)
userRepo := postgres.NewUserRepo(dbMiddleware)
uid, err := uuid.New().ID()
uid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
user := users.User{
ID: uid,
@ -100,7 +100,7 @@ func TestGroupRetrieveByID(t *testing.T) {
user, err = userRepo.RetrieveByEmail(context.Background(), user.Email)
require.Nil(t, err, fmt.Sprintf("retrieve got unexpected error: %s", err))
gid, err := uuid.New().ID()
gid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("group id unexpected error: %s", err))
group1 := users.Group{
ID: gid,
@ -108,7 +108,7 @@ func TestGroupRetrieveByID(t *testing.T) {
OwnerID: user.ID,
}
gid, err = uuid.New().ID()
gid, err = idProvider.ID()
require.Nil(t, err, fmt.Sprintf("group id unexpected error: %s", err))
group2 := users.Group{
ID: gid,
@ -122,7 +122,7 @@ func TestGroupRetrieveByID(t *testing.T) {
g2, err := repo.Save(context.Background(), group2)
require.Nil(t, err, fmt.Sprintf("group save got unexpected error: %s", err))
g2.ID, err = uuidProvider.New().ID()
g2.ID, err = idProvider.ID()
require.Nil(t, err, fmt.Sprintf("failed to generate id error: %s", err))
cases := []struct {
@ -152,7 +152,7 @@ func TestGroupUpdate(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
groupRepo := postgres.NewGroupRepo(dbMiddleware)
gid, err := uuid.New().ID()
gid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("group id unexpected error: %s", err))
group := users.Group{
ID: gid,
@ -211,7 +211,7 @@ func TestGroupDelete(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
repo := postgres.NewGroupRepo(dbMiddleware)
userRepo := postgres.NewUserRepo(dbMiddleware)
uid, err := uuid.New().ID()
uid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
user := users.User{
ID: uid,
@ -224,7 +224,7 @@ func TestGroupDelete(t *testing.T) {
user, err = userRepo.RetrieveByEmail(context.Background(), user.Email)
require.Nil(t, err, fmt.Sprintf("retrieve got unexpected error: %s", err))
gid, err := uuid.New().ID()
gid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("group id unexpected error: %s", err))
group1 := users.Group{
ID: gid,
@ -238,7 +238,7 @@ func TestGroupDelete(t *testing.T) {
err = repo.Assign(context.Background(), user.ID, g1.ID)
require.Nil(t, err, fmt.Sprintf("failed to assign user to a group: %s", err))
gid, err = uuid.New().ID()
gid, err = idProvider.ID()
require.Nil(t, err, fmt.Sprintf("group id unexpected error: %s", err))
group2 := users.Group{
ID: gid,
@ -276,7 +276,7 @@ func TestAssignUser(t *testing.T) {
dbMiddleware := postgres.NewDatabase(db)
repo := postgres.NewGroupRepo(dbMiddleware)
userRepo := postgres.NewUserRepo(dbMiddleware)
uid, err := uuid.New().ID()
uid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
user := users.User{
ID: uid,
@ -290,7 +290,7 @@ func TestAssignUser(t *testing.T) {
user, err = userRepo.RetrieveByEmail(context.Background(), user.Email)
require.Nil(t, err, fmt.Sprintf("retrieve got unexpected error: %s", err))
gid, err := uuid.New().ID()
gid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("group id unexpected error: %s", err))
group1 := users.Group{
ID: gid,
@ -301,7 +301,7 @@ func TestAssignUser(t *testing.T) {
g1, err := repo.Save(context.Background(), group1)
require.Nil(t, err, fmt.Sprintf("group save got unexpected error: %s", err))
gid, err = uuid.New().ID()
gid, err = idProvider.ID()
require.Nil(t, err, fmt.Sprintf("group id unexpected error: %s", err))
group2 := users.Group{
ID: gid,
@ -312,7 +312,7 @@ func TestAssignUser(t *testing.T) {
g2, err := repo.Save(context.Background(), group2)
require.Nil(t, err, fmt.Sprintf("group save got unexpected error: %s", err))
gid, err = uuidProvider.New().ID()
gid, err = idProvider.ID()
require.Nil(t, err, fmt.Sprintf("group id generating error: %s", err))
g3 := users.Group{
ID: gid,
@ -352,7 +352,7 @@ func TestUnassignUser(t *testing.T) {
repo := postgres.NewGroupRepo(dbMiddleware)
userRepo := postgres.NewUserRepo(dbMiddleware)
uid, err := uuid.New().ID()
uid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
user := users.User{
ID: uid,
@ -366,7 +366,7 @@ func TestUnassignUser(t *testing.T) {
user1, err := userRepo.RetrieveByEmail(context.Background(), user.Email)
require.Nil(t, err, fmt.Sprintf("retrieve got unexpected error: %s", err))
uid, err = uuid.New().ID()
uid, err = idProvider.ID()
require.Nil(t, err, fmt.Sprintf("got unexpected error: %s", err))
user = users.User{
ID: uid,
@ -380,7 +380,7 @@ func TestUnassignUser(t *testing.T) {
user2, err := userRepo.RetrieveByEmail(context.Background(), user.Email)
require.Nil(t, err, fmt.Sprintf("retrieve got unexpected error: %s", err))
gid, err := uuid.New().ID()
gid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("group id unexpected error: %s", err))
group1 := users.Group{
ID: gid,

12
users/postgres/users_test.go
View File

@ -16,10 +16,12 @@ import (
"github.com/stretchr/testify/require"
)
var idProvider = uuid.New()
func TestUserSave(t *testing.T) {
email := "user-save@example.com"
uid, err := uuid.New().ID()
uid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("unexpected error: %s", err))
cases := []struct {
@ -62,7 +64,7 @@ func TestSingleUserRetrieval(t *testing.T) {
email := "user-retrieval@example.com"
uid, err := uuid.New().ID()
uid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("unexpected error: %s", err))
user := users.User{
@ -95,7 +97,7 @@ func TestRetrieveMembers(t *testing.T) {
var nUsers = uint64(10)
var usrs []users.User
for i := uint64(0); i < nUsers; i++ {
uid, err := uuid.New().ID()
uid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("unexpected error: %s", err))
email := fmt.Sprintf("TestRetrieveMembers%d@example.com", i)
user := users.User{
@ -108,7 +110,7 @@ func TestRetrieveMembers(t *testing.T) {
u, _ := userRepo.RetrieveByEmail(context.Background(), user.Email)
usrs = append(usrs, u)
}
uid, err := uuid.New().ID()
uid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("user uuid error: %s", err))
group := users.Group{
ID: uid,
@ -155,7 +157,7 @@ func TestRetrieveAll(t *testing.T) {
var nUsers = uint64(10)
for i := uint64(0); i < nUsers; i++ {
uid, err := uuid.New().ID()
uid, err := idProvider.ID()
require.Nil(t, err, fmt.Sprintf("unexpected error: %s", err))
email := fmt.Sprintf("TestRetrieveAll%d@example.com", i)
user := users.User{

29
users/service.go
View File

@ -10,7 +10,6 @@ import (
"github.com/mainflux/mainflux"
"github.com/mainflux/mainflux/auth"
"github.com/mainflux/mainflux/pkg/errors"
uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
)
var (
@ -159,21 +158,23 @@ type UserPage struct {
var _ Service = (*usersService)(nil)
type usersService struct {
users UserRepository
groups GroupRepository
hasher Hasher
email Emailer
auth mainflux.AuthServiceClient
users UserRepository
groups GroupRepository
hasher Hasher
email Emailer
auth mainflux.AuthServiceClient
idProvider mainflux.IDProvider
}
// New instantiates the users service implementation
func New(users UserRepository, groups GroupRepository, hasher Hasher, auth mainflux.AuthServiceClient, m Emailer) Service {
func New(users UserRepository, groups GroupRepository, hasher Hasher, auth mainflux.AuthServiceClient, m Emailer, idp mainflux.IDProvider) Service {
return &usersService{
users: users,
groups: groups,
hasher: hasher,
auth: auth,
email: m,
users: users,
groups: groups,
hasher: hasher,
auth: auth,
email: m,
idProvider: idp,
}
}
@ -186,7 +187,7 @@ func (svc usersService) Register(ctx context.Context, user User) (string, error)
return "", errors.Wrap(ErrMalformedEntity, err)
}
user.Password = hash
uid, err := uuidProvider.New().ID()
uid, err := svc.idProvider.ID()
if err != nil {
return "", errors.Wrap(ErrCreateUser, err)
}
@ -335,7 +336,7 @@ func (svc usersService) CreateGroup(ctx context.Context, token string, group Gro
return Group{}, err
}
uid, err := uuidProvider.New().ID()
uid, err := svc.idProvider.ID()
if err != nil {
return Group{}, errors.Wrap(ErrCreateUser, err)
}

10
users/service_test.go
View File

@ -10,7 +10,7 @@ import (
"github.com/mainflux/mainflux"
"github.com/mainflux/mainflux/pkg/errors"
uuidProvider "github.com/mainflux/mainflux/pkg/uuid"
"github.com/mainflux/mainflux/pkg/uuid"
"github.com/mainflux/mainflux/users"
"github.com/mainflux/mainflux/users/mocks"
@ -25,6 +25,8 @@ var (
nonExistingUser = users.User{Email: "non-ex-user@example.com", Password: "password", Metadata: map[string]interface{}{"role": "user"}}
host = "example.com"
groupName = "Mainflux"
idProvider = uuid.New()
)
func newService() users.Service {
@ -34,7 +36,7 @@ func newService() users.Service {
auth := mocks.NewAuthService(map[string]string{user.Email: user.Email})
e := mocks.NewEmailer()
return users.New(userRepo, groupRepo, hasher, auth, e)
return users.New(userRepo, groupRepo, hasher, auth, e, idProvider)
}
func TestRegister(t *testing.T) {
@ -374,11 +376,11 @@ func TestCreateGroup(t *testing.T) {
token, err := svc.Login(context.Background(), user)
assert.Nil(t, err, fmt.Sprintf("authenticating user expected to succeed: %s", err))
uuid, err := uuidProvider.New().ID()
id, err := idProvider.ID()
assert.Nil(t, err, fmt.Sprintf("generating uuid expected to succeed: %s", err))
group := users.Group{
ID: uuid,
ID: id,
Name: groupName,
}

2
uuid.go
View File

@ -3,7 +3,7 @@
package mainflux
// UUIDProvider specifies an API for generating unique identifiers.
// IDProvider specifies an API for generating unique identifiers.
type IDProvider interface {
// ID generates the unique identifier.
ID() (string, error)