mirror of
https://github.com/elyby/chrly.git
synced 2024-07-01 04:43:21 +05:30
290 lines
8.7 KiB
Go
290 lines
8.7 KiB
Go
package mojangtextures
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/base64"
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
testify "github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/mock"
|
|
"github.com/stretchr/testify/suite"
|
|
|
|
"github.com/elyby/chrly/api/mojang"
|
|
mocks "github.com/elyby/chrly/tests"
|
|
)
|
|
|
|
func TestJobsQueue(t *testing.T) {
|
|
createQueue := func() *jobsQueue {
|
|
queue := &jobsQueue{}
|
|
queue.New()
|
|
|
|
return queue
|
|
}
|
|
|
|
t.Run("Enqueue", func(t *testing.T) {
|
|
assert := testify.New(t)
|
|
|
|
s := createQueue()
|
|
s.Enqueue(&jobItem{username: "username1"})
|
|
s.Enqueue(&jobItem{username: "username2"})
|
|
s.Enqueue(&jobItem{username: "username3"})
|
|
|
|
assert.Equal(3, s.Size())
|
|
})
|
|
|
|
t.Run("Dequeue", func(t *testing.T) {
|
|
assert := testify.New(t)
|
|
|
|
s := createQueue()
|
|
s.Enqueue(&jobItem{username: "username1"})
|
|
s.Enqueue(&jobItem{username: "username2"})
|
|
s.Enqueue(&jobItem{username: "username3"})
|
|
s.Enqueue(&jobItem{username: "username4"})
|
|
|
|
items := s.Dequeue(2)
|
|
assert.Len(items, 2)
|
|
assert.Equal("username1", items[0].username)
|
|
assert.Equal("username2", items[1].username)
|
|
assert.Equal(2, s.Size())
|
|
|
|
items = s.Dequeue(40)
|
|
assert.Len(items, 2)
|
|
assert.Equal("username3", items[0].username)
|
|
assert.Equal("username4", items[1].username)
|
|
})
|
|
}
|
|
|
|
// This is really stupid test just to get 100% coverage on this package :)
|
|
func TestBatchUuidsProvider_forever(t *testing.T) {
|
|
testify.True(t, forever())
|
|
}
|
|
|
|
type mojangUsernamesToUuidsRequestMock struct {
|
|
mock.Mock
|
|
}
|
|
|
|
func (o *mojangUsernamesToUuidsRequestMock) UsernamesToUuids(usernames []string) ([]*mojang.ProfileInfo, error) {
|
|
args := o.Called(usernames)
|
|
var result []*mojang.ProfileInfo
|
|
if casted, ok := args.Get(0).([]*mojang.ProfileInfo); ok {
|
|
result = casted
|
|
}
|
|
|
|
return result, args.Error(1)
|
|
}
|
|
|
|
type batchUuidsProviderGetUuidResult struct {
|
|
Result *mojang.ProfileInfo
|
|
Error error
|
|
}
|
|
|
|
type batchUuidsProviderTestSuite struct {
|
|
suite.Suite
|
|
|
|
Provider *BatchUuidsProvider
|
|
GetUuidAsync func(username string) chan *batchUuidsProviderGetUuidResult
|
|
|
|
Logger *mocks.WdMock
|
|
MojangApi *mojangUsernamesToUuidsRequestMock
|
|
|
|
Iterate func()
|
|
done func()
|
|
iterateChan chan bool
|
|
}
|
|
|
|
func (suite *batchUuidsProviderTestSuite) SetupTest() {
|
|
suite.Logger = &mocks.WdMock{}
|
|
|
|
suite.Provider = &BatchUuidsProvider{
|
|
Logger: suite.Logger,
|
|
IterationDelay: 0,
|
|
IterationSize: 10,
|
|
}
|
|
|
|
suite.iterateChan = make(chan bool)
|
|
forever = func() bool {
|
|
return <-suite.iterateChan
|
|
}
|
|
|
|
suite.Iterate = func() {
|
|
suite.iterateChan <- true
|
|
}
|
|
|
|
suite.done = func() {
|
|
suite.iterateChan <- false
|
|
}
|
|
|
|
var lock sync.Mutex
|
|
suite.GetUuidAsync = func(username string) chan *batchUuidsProviderGetUuidResult {
|
|
lock.Lock()
|
|
defer lock.Unlock()
|
|
|
|
c := make(chan *batchUuidsProviderGetUuidResult)
|
|
s := make(chan int)
|
|
go func() {
|
|
s <- 0
|
|
profile, err := suite.Provider.GetUuid(username)
|
|
c <- &batchUuidsProviderGetUuidResult{
|
|
Result: profile,
|
|
Error: err,
|
|
}
|
|
}()
|
|
|
|
<-s
|
|
|
|
return c
|
|
}
|
|
|
|
suite.MojangApi = &mojangUsernamesToUuidsRequestMock{}
|
|
usernamesToUuids = suite.MojangApi.UsernamesToUuids
|
|
}
|
|
|
|
func (suite *batchUuidsProviderTestSuite) TearDownTest() {
|
|
suite.done()
|
|
time.Sleep(10 * time.Millisecond) // Add delay to let finish all goroutines before assert mocks calls
|
|
suite.MojangApi.AssertExpectations(suite.T())
|
|
suite.Logger.AssertExpectations(suite.T())
|
|
}
|
|
|
|
func TestBatchUuidsProvider(t *testing.T) {
|
|
suite.Run(t, new(batchUuidsProviderTestSuite))
|
|
}
|
|
|
|
func (suite *batchUuidsProviderTestSuite) TestGetUuidForOneUsername() {
|
|
expectedResult := &mojang.ProfileInfo{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username"}
|
|
|
|
suite.Logger.On("IncCounter", "mojang_textures.usernames.queued", int64(1)).Once()
|
|
suite.Logger.On("UpdateGauge", "mojang_textures.usernames.iteration_size", int64(1)).Once()
|
|
suite.Logger.On("UpdateGauge", "mojang_textures.usernames.queue_size", int64(0)).Once()
|
|
suite.Logger.On("RecordTimer", "mojang_textures.usernames.round_time", mock.Anything).Once()
|
|
|
|
suite.MojangApi.On("UsernamesToUuids", []string{"username"}).Once().Return([]*mojang.ProfileInfo{expectedResult}, nil)
|
|
|
|
resultChan := suite.GetUuidAsync("username")
|
|
|
|
suite.Iterate()
|
|
|
|
result := <-resultChan
|
|
suite.Assert().Equal(expectedResult, result.Result)
|
|
suite.Assert().Nil(result.Error)
|
|
}
|
|
|
|
func (suite *batchUuidsProviderTestSuite) TestGetUuidForTwoUsernames() {
|
|
expectedResult1 := &mojang.ProfileInfo{Id: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Name: "username1"}
|
|
expectedResult2 := &mojang.ProfileInfo{Id: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Name: "username2"}
|
|
|
|
suite.Logger.On("IncCounter", "mojang_textures.usernames.queued", int64(1)).Twice()
|
|
suite.Logger.On("UpdateGauge", "mojang_textures.usernames.iteration_size", int64(2)).Once()
|
|
suite.Logger.On("UpdateGauge", "mojang_textures.usernames.queue_size", int64(0)).Once()
|
|
suite.Logger.On("RecordTimer", "mojang_textures.usernames.round_time", mock.Anything).Once()
|
|
|
|
suite.MojangApi.On("UsernamesToUuids", []string{"username1", "username2"}).Once().Return([]*mojang.ProfileInfo{
|
|
expectedResult1,
|
|
expectedResult2,
|
|
}, nil)
|
|
|
|
resultChan1 := suite.GetUuidAsync("username1")
|
|
resultChan2 := suite.GetUuidAsync("username2")
|
|
|
|
suite.Iterate()
|
|
|
|
result1 := <-resultChan1
|
|
suite.Assert().Equal(expectedResult1, result1.Result)
|
|
suite.Assert().Nil(result1.Error)
|
|
|
|
result2 := <-resultChan2
|
|
suite.Assert().Equal(expectedResult2, result2.Result)
|
|
suite.Assert().Nil(result2.Error)
|
|
}
|
|
|
|
func (suite *batchUuidsProviderTestSuite) TestGetUuidForMoreThan10Usernames() {
|
|
usernames := make([]string, 12)
|
|
for i := 0; i < cap(usernames); i++ {
|
|
usernames[i] = randStr(8)
|
|
}
|
|
|
|
suite.Logger.On("IncCounter", "mojang_textures.usernames.queued", int64(1)).Times(12)
|
|
suite.Logger.On("UpdateGauge", "mojang_textures.usernames.iteration_size", int64(10)).Once()
|
|
suite.Logger.On("UpdateGauge", "mojang_textures.usernames.iteration_size", int64(2)).Once()
|
|
suite.Logger.On("UpdateGauge", "mojang_textures.usernames.queue_size", int64(2)).Once()
|
|
suite.Logger.On("UpdateGauge", "mojang_textures.usernames.queue_size", int64(0)).Once()
|
|
suite.Logger.On("RecordTimer", "mojang_textures.usernames.round_time", mock.Anything).Twice()
|
|
|
|
suite.MojangApi.On("UsernamesToUuids", usernames[0:10]).Once().Return([]*mojang.ProfileInfo{}, nil)
|
|
suite.MojangApi.On("UsernamesToUuids", usernames[10:12]).Once().Return([]*mojang.ProfileInfo{}, nil)
|
|
|
|
channels := make([]chan *batchUuidsProviderGetUuidResult, len(usernames))
|
|
for i, username := range usernames {
|
|
channels[i] = suite.GetUuidAsync(username)
|
|
}
|
|
|
|
suite.Iterate()
|
|
suite.Iterate()
|
|
|
|
for _, channel := range channels {
|
|
<-channel
|
|
}
|
|
}
|
|
|
|
func (suite *batchUuidsProviderTestSuite) TestDoNothingWhenNoTasks() {
|
|
suite.Logger.On("IncCounter", "mojang_textures.usernames.queued", int64(1)).Once()
|
|
suite.Logger.On("UpdateGauge", "mojang_textures.usernames.iteration_size", int64(1)).Once()
|
|
suite.Logger.On("UpdateGauge", "mojang_textures.usernames.iteration_size", int64(0)).Twice()
|
|
suite.Logger.On("UpdateGauge", "mojang_textures.usernames.queue_size", int64(0)).Times(3)
|
|
suite.Logger.On("RecordTimer", "mojang_textures.usernames.round_time", mock.Anything)
|
|
|
|
suite.MojangApi.On("UsernamesToUuids", []string{"username"}).Once().Return([]*mojang.ProfileInfo{}, nil)
|
|
|
|
// Perform first iteration and await it finish
|
|
resultChan := suite.GetUuidAsync("username")
|
|
|
|
suite.Iterate()
|
|
|
|
result := <-resultChan
|
|
suite.Assert().Nil(result.Result)
|
|
suite.Assert().Nil(result.Error)
|
|
|
|
// Let it to perform a few more iterations to ensure, that there is no calls to external APIs
|
|
suite.Iterate()
|
|
suite.Iterate()
|
|
}
|
|
|
|
func (suite *batchUuidsProviderTestSuite) TestGetUuidForTwoUsernamesWithAnError() {
|
|
expectedError := &mojang.TooManyRequestsError{}
|
|
|
|
suite.Logger.On("IncCounter", "mojang_textures.usernames.queued", int64(1)).Twice()
|
|
suite.Logger.On("UpdateGauge", "mojang_textures.usernames.iteration_size", int64(2)).Once()
|
|
suite.Logger.On("UpdateGauge", "mojang_textures.usernames.queue_size", int64(0)).Once()
|
|
suite.Logger.On("RecordTimer", "mojang_textures.usernames.round_time", mock.Anything).Once()
|
|
|
|
suite.MojangApi.On("UsernamesToUuids", []string{"username1", "username2"}).Once().Return(nil, expectedError)
|
|
|
|
resultChan1 := suite.GetUuidAsync("username1")
|
|
resultChan2 := suite.GetUuidAsync("username2")
|
|
|
|
suite.Iterate()
|
|
|
|
result1 := <-resultChan1
|
|
suite.Assert().Nil(result1.Result)
|
|
suite.Assert().Equal(expectedError, result1.Error)
|
|
|
|
result2 := <-resultChan2
|
|
suite.Assert().Nil(result2.Result)
|
|
suite.Assert().Equal(expectedError, result2.Error)
|
|
}
|
|
|
|
var replacer = strings.NewReplacer("-", "_", "=", "")
|
|
|
|
// https://stackoverflow.com/a/50581165
|
|
func randStr(len int) string {
|
|
buff := make([]byte, len)
|
|
_, _ = rand.Read(buff)
|
|
str := replacer.Replace(base64.URLEncoding.EncodeToString(buff))
|
|
|
|
// Base 64 can be longer than len
|
|
return str[:len]
|
|
}
|