topfreegames/khan

package loadtest

import (
    "fmt"

    "github.com/topfreegames/khan/lib"
)

func (app *App) configureClanOperations() {
    app.appendOperation(app.getUpdateSharedClanScoreOperation())
    app.appendOperation(app.getCreateClanOperation())
    app.appendOperation(app.getRetrieveClanOperation())
    app.appendOperation(app.getLeaveClanOperation())
    app.appendOperation(app.getTransferClanOwnershipOperation())
    app.appendOperation(app.getSearchClansOperation())
    app.appendOperation(app.getRetrieveClansSummariesOperation())
}

func (app *App) getUpdateSharedClanScoreOperation() operation {
    operationKey := "updateSharedClanScore"
    app.setOperationProbabilityConfigDefault(operationKey, 1)
    return operation{
        probability: app.getOperationProbabilityConfig(operationKey),
        canExecute: func() (bool, error) {
            count, err := app.cache.getSharedClansCount()
            if err != nil {
                return false, err
            }
            return count > 0, nil
        },
        execute: func() error {
            clanPublicID, playerPublicID, err := app.cache.chooseRandomSharedClanAndPlayer()
            if err != nil {
                return err
            }

            // updatePlayer
            result, err := app.client.UpdatePlayer(nil, playerPublicID, getRandomPlayerName(), getMetadataWithRandomScore())
            if err != nil {
                return err
            }
            if result == nil {
                return &GenericError{"NilPayloadError", "Operation updatePlayer returned no error with nil payload."}
            }
            if !result.Success {
                return &GenericError{"FailurePayloadError", "Operation updatePlayer returned no error with failure payload."}
            }

            // getClan
            clan, err := app.client.RetrieveClan(nil, clanPublicID)
            if err != nil {
                return err
            }
            if clan == nil {
                return &GenericError{"NilPayloadError", "Operation retrieveClan returned no error with nil payload."}
            }
            if clan.PublicID != clanPublicID {
                return &GenericError{"WrongPublicIDError", "Operation retrieveClan returned no error with public ID different from requested."}
            }

            // updateClan
            clanScore := getScoreFromMetadata(clan.Owner.Metadata)
            for _, member := range clan.Roster {
                clanScore += getScoreFromMetadata(member.Player.Metadata)
            }
            clanMetadata := map[string]interface{}{
                "score": clanScore,
            }
            result, err = app.client.UpdateClan(nil, &lib.ClanPayload{
                PublicID:         clan.PublicID,
                Name:             clan.Name,
                OwnerPublicID:    clan.Owner.PublicID,
                Metadata:         clanMetadata,
                AllowApplication: clan.AllowApplication,
                AutoJoin:         clan.AutoJoin,
            })
            if err != nil {
                return err
            }
            if result == nil {
                return &GenericError{"NilPayloadError", "Operation updateClan returned no error with nil payload."}
            }
            if !result.Success {
                return &GenericError{"FailurePayloadError", "Operation updateclan returned no error with failure payload."}
            }

            return nil
        },
    }
}

func (app *App) getCreateClanOperation() operation {
    operationKey := "createClan"

    // set default configs
    app.setOperationProbabilityConfigDefault(operationKey, 1)
    autoJoinKey := fmt.Sprintf("loadtest.operations.%s.autoJoin", operationKey)
    app.config.SetDefault(autoJoinKey, true)
    autoJoin := app.config.GetBool(autoJoinKey)
    return operation{
        probability: app.getOperationProbabilityConfig(operationKey),
        canExecute: func() (bool, error) {
            count, err := app.cache.getFreePlayersCount()
            if err != nil {
                return false, err
            }
            return count > 0, nil
        },
        execute: func() error {
            playerPublicID, err := app.cache.chooseRandomFreePlayer()
            if err != nil {
                return err
            }

            clanPublicID := getRandomPublicID()
            createdPublicID, err := app.client.CreateClan(nil, &lib.ClanPayload{
                PublicID:         clanPublicID,
                Name:             getRandomClanName(),
                OwnerPublicID:    playerPublicID,
                Metadata:         getMetadataWithRandomScore(),
                AllowApplication: true,
                AutoJoin:         autoJoin,
            })
            if err != nil {
                return err
            }
            if createdPublicID != clanPublicID {
                return &GenericError{"WrongPublicIDError", "Operation createClan returned no error with public ID different from requested."}
            }

            return app.cache.createClan(clanPublicID, playerPublicID)
        },
    }
}

func (app *App) getRetrieveClanOperation() operation {
    operationKey := "retrieveClan"
    app.setOperationProbabilityConfigDefault(operationKey, 1)
    return operation{
        probability: app.getOperationProbabilityConfig(operationKey),
        canExecute: func() (bool, error) {
            count, err := app.cache.getOwnerPlayersCount()
            if err != nil {
                return false, err
            }
            return count > 0, nil
        },
        execute: func() error {
            clanPublicID, err := app.cache.chooseRandomClan()
            if err != nil {
                return err
            }

            clan, err := app.client.RetrieveClan(nil, clanPublicID)
            if err != nil {
                return err
            }
            if clan == nil {
                return &GenericError{"NilPayloadError", "Operation retrieveClan returned no error with nil payload."}
            }
            if clan.PublicID != clanPublicID {
                return &GenericError{"WrongPublicIDError", "Operation retrieveClan returned no error with public ID different from requested."}
            }

            return nil
        },
    }
}

func (app *App) getLeaveClanOperation() operation {
    operationKey := "leaveClan"
    app.setOperationProbabilityConfigDefault(operationKey, 1)
    return operation{
        probability: app.getOperationProbabilityConfig(operationKey),
        canExecute: func() (bool, error) {
            count, err := app.cache.getOwnerPlayersCount()
            if err != nil {
                return false, err
            }
            return count > 0, nil
        },
        execute: func() error {
            clanPublicID, err := app.cache.chooseRandomClan()
            if err != nil {
                return err
            }

            leaveClanResult, err := app.client.LeaveClan(nil, clanPublicID)
            if err != nil {
                return err
            }
            if leaveClanResult == nil {
                return &GenericError{"NilPayloadError", "Operation leaveClan returned no error with nil payload."}
            }

            oldOwnerPublicID := leaveClanResult.PreviousOwner.PublicID
            newOwnerPublicID := ""
            if leaveClanResult.NewOwner != nil {
                newOwnerPublicID = leaveClanResult.NewOwner.PublicID
            }
            return app.cache.leaveClan(clanPublicID, oldOwnerPublicID, newOwnerPublicID)
        },
    }
}

func (app *App) getTransferClanOwnershipOperation() operation {
    operationKey := "transferClanOwnership"
    app.setOperationProbabilityConfigDefault(operationKey, 1)
    return operation{
        probability: app.getOperationProbabilityConfig(operationKey),
        canExecute: func() (bool, error) {
            count, err := app.cache.getMemberPlayersCount()
            if err != nil {
                return false, nil
            }
            return count > 0, nil
        },
        execute: func() error {
            newOwnerPublicID, clanPublicID, err := app.cache.chooseRandomMemberPlayerAndClan()
            if err != nil {
                return err
            }

            transferOwnershipResult, err := app.client.TransferOwnership(nil, newOwnerPublicID, clanPublicID)
            if err != nil {
                return err
            }
            if transferOwnershipResult == nil {
                return &GenericError{"NilPayloadError", "Operation transferClanOwnership returned no error with nil payload."}
            }

            oldOwnerPublicID := transferOwnershipResult.PreviousOwner.PublicID
            return app.cache.transferClanOwnership(clanPublicID, oldOwnerPublicID, newOwnerPublicID)
        },
    }
}

func (app *App) getSearchClansOperation() operation {
    operationKey := "searchClans"
    app.setOperationProbabilityConfigDefault(operationKey, 1)
    return operation{
        probability: app.getOperationProbabilityConfig(operationKey),
        canExecute: func() (bool, error) {
            return true, nil
        },
        execute: func() error {
            searchClansResult, err := app.client.SearchClans(nil, getRandomClanName())
            if err != nil {
                return err
            }
            if searchClansResult == nil {
                return &GenericError{"NilPayloadError", "Operation searchClans returned no error with nil payload."}
            }
            if !searchClansResult.Success {
                return &GenericError{"FailurePayloadError", "Operation searchClans returned no error with failure payload."}
            }
            return nil
        },
    }
}

func (app *App) getRetrieveClansSummariesOperation() operation {
    operationKey := "retrieveClansSummaries"
    app.setOperationProbabilityConfigDefault(operationKey, 1)
    return operation{
        probability: app.getOperationProbabilityConfig(operationKey),
        canExecute: func() (bool, error) {
            return true, nil
        },
        execute: func() error {
            sharedClans, err := app.cache.getSharedClansPublicIDs()
            if err != nil {
                return err
            }
            sharedClansMap := make(map[string]bool)
            for _, clan := range sharedClans {
                sharedClansMap[clan] = true
            }
            clansSummaries, err := app.client.RetrieveClansSummary(nil, sharedClans)
            if err != nil {
                return err
            }
            for _, clanSummary := range clansSummaries {
                if clanSummary == nil {
                    return &GenericError{"NilPayloadError", "Operation retrieveClansSummaries returned no error with nil payload."}
                }
                if !sharedClansMap[clanSummary.PublicID] {
                    return &GenericError{"WrongPublicIDError", "Operation retrieveClansSummaries returned no error with public ID different from requested."}
                }
            }
            return nil
        },
    }
}