mock

package
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
}

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.