mock

package
Version: v0.0.0-...-24b4de3 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Feb 19, 2018 License: GPL-2.0-only Imports: 2 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Achievement

type Achievement struct {
	ExistsMock          AchievementExists
	SingleMock          AchievementSingle
	CreateMock          AchievementCreate
	LastIDMock          AchievementsLastID
	LastIDByQuestIDMock AchievementsLastIDByQuestID
	AfterMock           AchievementsAfter
	AfterByQuestIDMock  AchievementsAfterByQuestID
}

func (*Achievement) After

func (ctx *Achievement) After(afterID string) ([]interface{}, error)

func (*Achievement) AfterByQuestID

func (ctx *Achievement) AfterByQuestID(questID string, afterID string) ([]interface{}, error)

func (*Achievement) Create

func (ctx *Achievement) Create(achievement interface{}) (string, error)

func (*Achievement) Exists

func (ctx *Achievement) Exists(id interface{}) (bool, error)

func (*Achievement) LastID

func (ctx *Achievement) LastID() (string, error)

func (*Achievement) LastIDByQuestID

func (ctx *Achievement) LastIDByQuestID(questID string) (string, error)

func (*Achievement) Single

func (ctx *Achievement) Single(id string) (interface{}, error)

type AchievementCreate

type AchievementCreate struct {
	ID  string
	Err error
}

type AchievementExists

type AchievementExists struct {
	Bool bool
	Err  error
}

type AchievementSingle

type AchievementSingle struct {
	Ach interface{}
	Err error
}

type AchievementsAfter

type AchievementsAfter struct {
	Achs []interface{}
	Err  error
}

type AchievementsAfterByQuestID

type AchievementsAfterByQuestID struct {
	Achs []interface{}
	Err  error
}

type AchievementsLastID

type AchievementsLastID struct {
	ID  string
	Err error
}

type AchievementsLastIDByQuestID

type AchievementsLastIDByQuestID struct {
	ID  string
	Err error
}

type DB

type DB struct {
	UUIDMock UUID

	UserMock             User
	ProfileMock          Profile
	AchievementMock      Achievement
	EvidenceMock         Evidence
	RewardMock           Reward
	RewardTypeMock       RewardType
	QuestMock            Quest
	QuestTypeMock        QuestType
	QuestAchievementMock QuestAchievement
	InvolvementMock      Involvement
	MultimediaTypeMock   MultimediaType
}

func (*DB) Achievement

func (mock *DB) Achievement() db.Achievementer

func (*DB) Evidence

func (mock *DB) Evidence() db.Evidencer

func (*DB) Involvement

func (mock *DB) Involvement() db.Involvementer

func (*DB) MultimediaType

func (mock *DB) MultimediaType() db.MultimediaTyper

func (*DB) Profile

func (mock *DB) Profile() db.Profiler

func (*DB) Quest

func (mock *DB) Quest() db.Quester

func (*DB) QuestAchievement

func (mock *DB) QuestAchievement() db.QuestAchievementer

func (*DB) QuestType

func (mock *DB) QuestType() db.QuestTyper

func (*DB) Reward

func (mock *DB) Reward() db.Rewarder

func (*DB) RewardType

func (mock *DB) RewardType() db.RewardTyper

func (*DB) UUID

func (mock *DB) UUID() (string, error)

func (*DB) User

func (mock *DB) User() db.Userer

type Evidence

type Evidence struct {
	ExistsMock EvidenceExists
	SingleMock EvidenceSingle
	CreateMock EvidenceCreate
	LastIDMock EvidencesLastID
	AfterMock  EvidencesAfter
}

func (*Evidence) After

func (ctx *Evidence) After(afterID string) ([]interface{}, error)

func (*Evidence) Create

func (ctx *Evidence) Create(evidence interface{}) (string, error)

func (*Evidence) Exists

func (ctx *Evidence) Exists(id interface{}) (bool, error)

func (*Evidence) LastID

func (ctx *Evidence) LastID() (string, error)

func (*Evidence) Single

func (ctx *Evidence) Single(id string) (interface{}, error)

type EvidenceCreate

type EvidenceCreate struct {
	ID  string
	Err error
}

type EvidenceExists

type EvidenceExists struct {
	Bool bool
	Err  error
}

type EvidenceSingle

type EvidenceSingle struct {
	Evd interface{}
	Err error
}

type EvidencesAfter

type EvidencesAfter struct {
	Evds []interface{}
	Err  error
}

type EvidencesLastID

type EvidencesLastID struct {
	ID  string
	Err error
}

type Involvement

type Involvement struct {
	ExistsMock InvolvementExists
}

func (*Involvement) Exists

func (ctx *Involvement) Exists(id interface{}) (bool, error)

type InvolvementExists

type InvolvementExists struct {
	Bool bool
	Err  error
}

type MultimediaType

type MultimediaType struct {
	ExistsMock MultimediaTypeExists
}

func (*MultimediaType) Exists

func (ctx *MultimediaType) Exists(id interface{}) (bool, error)

type MultimediaTypeExists

type MultimediaTypeExists struct {
	Bool bool
	Err  error
}

type Profile

type Profile struct {
	ExistsMock         ProfileExists
	SingleMock         ProfileSingle
	SingleByUserIDMock ProfileSingleByUserID
	CreateMock         ProfileCreate
}

func (*Profile) Create

func (ctx *Profile) Create(profile interface{}) (string, error)

func (*Profile) Exists

func (ctx *Profile) Exists(id interface{}) (bool, error)

func (*Profile) Single

func (ctx *Profile) Single(id string) (interface{}, error)

func (*Profile) SingleByUserID

func (ctx *Profile) SingleByUserID(userID string) (interface{}, error)

type ProfileCreate

type ProfileCreate struct {
	ID  string
	Err error
}

type ProfileExists

type ProfileExists struct {
	Bool bool
	Err  error
}

type ProfileSingle

type ProfileSingle struct {
	Prfl interface{}
	Err  error
}

type ProfileSingleByUserID

type ProfileSingleByUserID struct {
	Prfl interface{}
	Err  error
}

type Quest

type Quest struct {
	ExistsMock QuestExists
	SingleMock QuestSingle
	CreateMock QuestCreate
	LastIDMock QuestsLastID
	AfterMock  QuestsAfter
}

func (*Quest) After

func (ctx *Quest) After(afterID string) ([]interface{}, error)

func (*Quest) Create

func (ctx *Quest) Create(quest interface{}) (string, error)

func (*Quest) Exists

func (ctx *Quest) Exists(id interface{}) (bool, error)

func (*Quest) LastID

func (ctx *Quest) LastID() (string, error)

func (*Quest) Single

func (ctx *Quest) Single(id string) (interface{}, error)

type QuestAchievement

type QuestAchievement struct {
	ExistsMock QuestAchievementExists
	CreateMock QuestAchievementCreate
}

func (*QuestAchievement) Create

func (ctx *QuestAchievement) Create(qstAch interface{}) (string, error)

func (*QuestAchievement) Exists

func (ctx *QuestAchievement) Exists(...interface{}) (bool, error)

type QuestAchievementCreate

type QuestAchievementCreate struct {
	ID  string
	Err error
}

type QuestAchievementExists

type QuestAchievementExists struct {
	Bool bool
	Err  error
}

type QuestCreate

type QuestCreate struct {
	ID  string
	Err error
}

type QuestExists

type QuestExists struct {
	Bool bool
	Err  error
}

type QuestSingle

type QuestSingle struct {
	Qst interface{}
	Err error
}

type QuestType

type QuestType struct {
	ExistsMock QuestTypeExists
}

func (*QuestType) Exists

func (ctx *QuestType) Exists(id interface{}) (bool, error)

type QuestTypeExists

type QuestTypeExists struct {
	Bool bool
	Err  error
}

type QuestsAfter

type QuestsAfter struct {
	Qsts []interface{}
	Err  error
}

type QuestsLastID

type QuestsLastID struct {
	ID  string
	Err error
}

type Reward

type Reward struct {
	ExistsMock RewardExists
	SingleMock RewardSingle
	CreateMock RewardCreate
	LastIDMock RewardsLastID
	AfterMock  RewardsAfter
}

func (*Reward) After

func (ctx *Reward) After(afterID string) ([]interface{}, error)

func (*Reward) Create

func (ctx *Reward) Create(reward interface{}) (string, error)

func (*Reward) Exists

func (ctx *Reward) Exists(id interface{}) (bool, error)

func (*Reward) LastID

func (ctx *Reward) LastID() (string, error)

func (*Reward) Single

func (ctx *Reward) Single(id string) (interface{}, error)

type RewardCreate

type RewardCreate struct {
	ID  string
	Err error
}

type RewardExists

type RewardExists struct {
	Bool bool
	Err  error
}

type RewardSingle

type RewardSingle struct {
	Rwd interface{}
	Err error
}

type RewardType

type RewardType struct {
	ExistsMock RewardTypeExists
}

func (*RewardType) Exists

func (ctx *RewardType) Exists(id interface{}) (bool, error)

type RewardTypeExists

type RewardTypeExists struct {
	Bool bool
	Err  error
}

type RewardsAfter

type RewardsAfter struct {
	Rwds []interface{}
	Err  error
}

type RewardsLastID

type RewardsLastID struct {
	ID  string
	Err error
}

type UUID

type UUID struct {
	UUID string
	Err  error
}

type User

type User struct {
	ExistsMock      UserExists
	EmailExistsMock UserEmailExists
	AuthMock        UserAuth
	CreateMock      UserCreate
}

func (*User) Auth

func (ctx *User) Auth(auth *model.Auth) (string, error)

func (*User) Create

func (ctx *User) Create(user *model.User) (string, error)

func (*User) EmailExists

func (ctx *User) EmailExists(email string) (bool, error)

func (*User) Exists

func (ctx *User) Exists(id interface{}) (bool, error)

type UserAuth

type UserAuth struct {
	ID  string
	Err error
}

type UserCreate

type UserCreate struct {
	ID  string
	Err error
}

type UserEmailExists

type UserEmailExists struct {
	Bool bool
	Err  error
}

type UserExists

type UserExists struct {
	Bool bool
	Err  error
}

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL