157 lines
3.2 KiB
Go
157 lines
3.2 KiB
Go
// Copyright (c) HashiCorp, Inc.
|
|
// SPDX-License-Identifier: MPL-2.0
|
|
|
|
//go:build unix
|
|
|
|
package users
|
|
|
|
import (
|
|
"errors"
|
|
"os/user"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/hashicorp/nomad/ci"
|
|
"github.com/shoenig/test/must"
|
|
"oss.indeed.com/go/libtime/libtimetest"
|
|
)
|
|
|
|
func TestCache_real_hit(t *testing.T) {
|
|
ci.Parallel(t)
|
|
|
|
c := newCache()
|
|
|
|
// fresh lookup
|
|
u, err := c.GetUser("nobody")
|
|
must.NoError(t, err)
|
|
must.NotNil(t, u)
|
|
|
|
// hit again, cached value
|
|
u2, err2 := c.GetUser("nobody")
|
|
must.NoError(t, err2)
|
|
must.NotNil(t, u2)
|
|
must.True(t, u == u2) // compare pointers
|
|
}
|
|
|
|
func TestCache_real_miss(t *testing.T) {
|
|
ci.Parallel(t)
|
|
|
|
c := newCache()
|
|
|
|
// fresh lookup
|
|
u, err := c.GetUser("doesnotexist")
|
|
must.Error(t, err)
|
|
must.Nil(t, u)
|
|
|
|
// hit again, cached value
|
|
u2, err2 := c.GetUser("doesnotexist")
|
|
must.Error(t, err2)
|
|
must.Nil(t, u2)
|
|
must.True(t, err == err2) // compare pointers
|
|
}
|
|
|
|
func TestCache_mock_hit(t *testing.T) {
|
|
ci.Parallel(t)
|
|
|
|
c := newCache()
|
|
|
|
lookupCount := 0
|
|
|
|
// hijack the underlying lookup function with our own mock
|
|
c.lookupUser = func(username string) (*user.User, error) {
|
|
lookupCount++
|
|
return &user.User{Name: username}, nil
|
|
}
|
|
|
|
// hijack the clock with our own mock
|
|
t0 := time.Now()
|
|
clockCount := 0
|
|
c.clock = libtimetest.NewClockMock(t).NowMock.Set(func() time.Time {
|
|
clockCount++
|
|
switch clockCount {
|
|
case 1:
|
|
return t0
|
|
case 2:
|
|
return t0.Add(59 * time.Minute)
|
|
default:
|
|
return t0.Add(61 * time.Minute)
|
|
}
|
|
})
|
|
|
|
const username = "armon"
|
|
|
|
// initial lookup
|
|
u, err := c.GetUser(username)
|
|
must.NoError(t, err)
|
|
must.Eq(t, "armon", u.Name)
|
|
must.Eq(t, 1, lookupCount)
|
|
must.Eq(t, 1, clockCount)
|
|
|
|
// second lookup, 59 minutes after initil lookup
|
|
u2, err2 := c.GetUser(username)
|
|
must.NoError(t, err2)
|
|
must.Eq(t, "armon", u2.Name)
|
|
must.Eq(t, 1, lookupCount) // was in cache
|
|
must.Eq(t, 2, clockCount)
|
|
|
|
// third lookup, 61 minutes after initial lookup (expired)
|
|
u3, err3 := c.GetUser(username)
|
|
must.NoError(t, err3)
|
|
must.Eq(t, "armon", u3.Name)
|
|
must.Eq(t, 2, lookupCount)
|
|
must.Eq(t, 3, clockCount)
|
|
}
|
|
|
|
func TestCache_mock_miss(t *testing.T) {
|
|
ci.Parallel(t)
|
|
|
|
c := newCache()
|
|
|
|
lookupCount := 0
|
|
lookupErr := errors.New("lookup error")
|
|
|
|
// hijack the underlying lookup function with our own mock
|
|
c.lookupUser = func(username string) (*user.User, error) {
|
|
lookupCount++
|
|
return nil, lookupErr
|
|
}
|
|
|
|
// hijack the clock with our own mock
|
|
t0 := time.Now()
|
|
clockCount := 0
|
|
c.clock = libtimetest.NewClockMock(t).NowMock.Set(func() time.Time {
|
|
clockCount++
|
|
switch clockCount {
|
|
case 1:
|
|
return t0
|
|
case 2:
|
|
return t0.Add(59 * time.Second)
|
|
default:
|
|
return t0.Add(61 * time.Second)
|
|
}
|
|
})
|
|
|
|
const username = "armon"
|
|
|
|
// initial lookup
|
|
u, err := c.GetUser(username)
|
|
must.ErrorIs(t, err, lookupErr)
|
|
must.Nil(t, u)
|
|
must.Eq(t, 1, lookupCount)
|
|
must.Eq(t, 1, clockCount)
|
|
|
|
// second lookup, 59 seconds after initial (still in cache)
|
|
u2, err2 := c.GetUser(username)
|
|
must.ErrorIs(t, err2, lookupErr)
|
|
must.Nil(t, u2)
|
|
must.Eq(t, 1, lookupCount) // in cache
|
|
must.Eq(t, 2, clockCount)
|
|
|
|
// third lookup, 61 seconds after initial (expired)
|
|
u3, err3 := c.GetUser(username)
|
|
must.ErrorIs(t, err3, lookupErr)
|
|
must.Nil(t, u3)
|
|
must.Eq(t, 2, lookupCount)
|
|
must.Eq(t, 3, clockCount)
|
|
}
|