mudhorn/oh-my-posh
1
0
Fork 0
mirror of https://github.com/JanDeDobbeleer/oh-my-posh.git synced 2024-12-28 20:39:40 -08:00
Code Issues Actions Packages Projects Releases Wiki Activity

refactor: remove the need for nil argument in mock

Browse source
This commit is contained in:
Jan De Dobbeleer 2022-01-15 20:37:46 +01:00 committed by Jan De Dobbeleer
parent badb2ffc5e
commit 0404976b5c
35 changed files with 208 additions and 208 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

28
src/console_title_test.go
View file

@ -54,14 +54,14 @@ func TestGetConsoleTitle(t *testing.T) {
ConsoleTitleTemplate: tc.Template,
}
env := new(MockedEnvironment)
env.On("getcwd", nil).Return(tc.Cwd)
env.On("homeDir", nil).Return("/usr/home")
env.On("getPathSeperator", nil).Return(tc.PathSeperator)
env.On("isRunningAsRoot", nil).Return(tc.Root)
env.On("getShellName", nil).Return(tc.ShellName)
env.On("getcwd").Return(tc.Cwd)
env.On("homeDir").Return("/usr/home")
env.On("getPathSeperator").Return(tc.PathSeperator)
env.On("isRunningAsRoot").Return(tc.Root)
env.On("getShellName").Return(tc.ShellName)
env.On("getenv", "USERDOMAIN").Return("MyCompany")
env.On("getCurrentUser", nil).Return("MyUser")
env.On("getHostName", nil).Return("MyHost", nil)
env.On("getCurrentUser").Return("MyUser")
env.On("getHostName").Return("MyHost", nil)
env.onTemplate()
ansi := &ansiUtils{}
ansi.init(tc.ShellName)
@ -110,14 +110,14 @@ func TestGetConsoleTitleIfGethostnameReturnsError(t *testing.T) {
ConsoleTitleTemplate: tc.Template,
}
env := new(MockedEnvironment)
env.On("getcwd", nil).Return(tc.Cwd)
env.On("homeDir", nil).Return("/usr/home")
env.On("getPathSeperator", nil).Return(tc.PathSeperator)
env.On("isRunningAsRoot", nil).Return(tc.Root)
env.On("getShellName", nil).Return(tc.ShellName)
env.On("getcwd").Return(tc.Cwd)
env.On("homeDir").Return("/usr/home")
env.On("getPathSeperator").Return(tc.PathSeperator)
env.On("isRunningAsRoot").Return(tc.Root)
env.On("getShellName").Return(tc.ShellName)
env.On("getenv", "USERDOMAIN").Return("MyCompany")
env.On("getCurrentUser", nil).Return("MyUser")
env.On("getHostName", nil).Return("", fmt.Errorf("I have a bad feeling about this"))
env.On("getCurrentUser").Return("MyUser")
env.On("getHostName").Return("", fmt.Errorf("I have a bad feeling about this"))
env.onTemplate()
ansi := &ansiUtils{}
ansi.init(tc.ShellName)

2
src/engine_test.go
View file

@ -30,7 +30,7 @@ func TestCanWriteRPrompt(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getTerminalWidth", nil).Return(tc.TerminalWidth, tc.TerminalWidthError)
env.On("getTerminalWidth").Return(tc.TerminalWidth, tc.TerminalWidthError)
ansi := &ansiUtils{}
ansi.init(plain)
engine := &engine{

4
src/regex_test.go
View file

@ -32,8 +32,8 @@ func TestDirMatchesOneOf(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getRuntimeGOOS", nil).Return(tc.GOOS)
env.On("homeDir", nil).Return(tc.HomeDir)
env.On("getRuntimeGOOS").Return(tc.GOOS)
env.On("homeDir").Return(tc.HomeDir)
got := dirMatchesOneOf(env, tc.Dir, []string{tc.Pattern})
assert.Equal(t, tc.Expected, got)
}

4
src/scm_test.go
View file

@ -174,8 +174,8 @@ func TestScmShouldIgnoreRootRepository(t *testing.T) {
},
}
env := new(MockedEnvironment)
env.On("homeDir", nil).Return("/home/bill")
env.On("getRuntimeGOOS", nil).Return(windowsPlatform)
env.On("homeDir").Return("/home/bill")
env.On("getRuntimeGOOS").Return(windowsPlatform)
s := &scm{
props: props,
env: env,

4
src/segment_angular_test.go
View file

@ -24,8 +24,8 @@ func TestAngularCliVersionDisplayed(t *testing.T) {
var env = new(MockedEnvironment)
// mock getVersion methods
env.On("getcwd", nil).Return("/usr/home/dev/my-app")
env.On("homeDir", nil).Return("/usr/home")
env.On("getcwd").Return("/usr/home/dev/my-app")
env.On("homeDir").Return("/usr/home")
env.On("hasFiles", params.extension).Return(true)
env.On("hasFilesInDir", "/usr/home/dev/my-app/node_modules/@angular/core", "package.json").Return(true)
env.On("getFileContent", "/usr/home/dev/my-app/node_modules/@angular/core/package.json").Return(ta.Version)

2
src/segment_aws_test.go
View file

@ -53,7 +53,7 @@ func TestAWSSegment(t *testing.T) {
env.On("getenv", "AWS_DEFAULT_REGION").Return(tc.DefaultRegion)
env.On("getenv", "AWS_CONFIG_FILE").Return(tc.ConfigFile)
env.On("getFileContent", "/usr/home/.aws/config").Return("")
env.On("homeDir", nil).Return("/usr/home")
env.On("homeDir").Return("/usr/home")
env.onTemplate()
props := properties{
DisplayDefault: tc.DisplayDefault,

4
src/segment_az_test.go
View file

@ -69,7 +69,7 @@ func TestAzSegment(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
home := "/Users/posh"
env.On("homeDir", nil).Return(home)
env.On("homeDir").Return(home)
var azureProfile, azureRmContext, azureRMContext string
if tc.HasCLI {
content, _ := ioutil.ReadFile("./test/azureProfile.json")
@ -83,7 +83,7 @@ func TestAzSegment(t *testing.T) {
content, _ := ioutil.ReadFile("./test/AzureRmContext.json")
azureRMContext = string(content)
}
env.On("getRuntimeGOOS", nil).Return(linuxPlatform)
env.On("getRuntimeGOOS").Return(linuxPlatform)
env.On("getFileContent", filepath.Join(home, ".azure", "azureProfile.json")).Return(azureProfile)
env.On("getFileContent", filepath.Join(home, ".Azure", "AzureRmContext.json")).Return(azureRmContext)
env.On("getFileContent", filepath.Join(home, ".azure", "AzureRmContext.json")).Return(azureRMContext)

2
src/segment_brewfather_test.go
View file

@ -150,7 +150,7 @@ func TestBrewfatherSegment(t *testing.T) {
env.On("HTTPRequest", BFBatchURL).Return([]byte(tc.BatchJSONResponse), tc.Error)
env.On("HTTPRequest", BFBatchReadingsURL).Return([]byte(tc.BatchReadingsJSONResponse), tc.Error)
env.On("cache", nil).Return(cache)
env.On("cache").Return(cache)
env.onTemplate()
if tc.Template != "" {
props[SegmentTemplate] = tc.Template

24
src/segment_deprecated_test.go
View file

@ -270,8 +270,8 @@ func TestStatusColorsWithoutDisplayStatus(t *testing.T) {
expected := changesColor
status := "## main...origin/main [ahead 33]\n M myfile"
env := new(MockedEnvironment)
env.On("isWsl", nil).Return(false)
env.On("getRuntimeGOOS", nil).Return("unix")
env.On("isWsl").Return(false)
env.On("getRuntimeGOOS").Return("unix")
env.On("hasFolder", "/rebase-merge").Return(false)
env.On("hasFolder", "/rebase-apply").Return(false)
env.On("hasFolder", "/sequencer").Return(false)
@ -324,7 +324,7 @@ func TestExitWriterDeprecatedString(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("lastErrorCode", nil).Return(tc.ExitCode)
env.On("lastErrorCode").Return(tc.ExitCode)
props := properties{
SuccessIcon: tc.SuccessIcon,
ErrorIcon: tc.ErrorIcon,
@ -446,7 +446,7 @@ func TestBatterySegmentSingle(t *testing.T) {
if tc.DisableCharged {
props[DisplayCharged] = false
}
env.On("getBatteryInfo", nil).Return(tc.Batteries, tc.Error)
env.On("getBatteryInfo").Return(tc.Batteries, tc.Error)
env.onTemplate()
b := &batt{
props: props,
@ -623,12 +623,12 @@ func TestPropertySessionSegment(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getCurrentUser", nil).Return(tc.UserName)
env.On("getRuntimeGOOS", nil).Return(tc.GOOS)
env.On("getCurrentUser").Return(tc.UserName)
env.On("getRuntimeGOOS").Return(tc.GOOS)
if tc.HostError {
env.On("getHostName", nil).Return(tc.Host, errors.New("oh snap"))
env.On("getHostName").Return(tc.Host, errors.New("oh snap"))
} else {
env.On("getHostName", nil).Return(tc.Host, nil)
env.On("getHostName").Return(tc.Host, nil)
}
var SSHSession string
if tc.SSHSession {
@ -642,7 +642,7 @@ func TestPropertySessionSegment(t *testing.T) {
env.On("getenv", "SSH_CLIENT").Return(SSHClient)
env.On("getenv", "SSH_CLIENT").Return(SSHSession)
env.On("getenv", defaultUserEnvVar).Return(tc.DefaultUserNameEnv)
env.On("isRunningAsRoot", nil).Return(tc.Root)
env.On("isRunningAsRoot").Return(tc.Root)
props := properties{
UserInfoSeparator: " at ",
SSHIcon: "ssh ",
@ -754,9 +754,9 @@ func TestPythonVirtualEnv(t *testing.T) {
env.On("getenv", "CONDA_ENV_PATH").Return(tc.CondaEnvName)
env.On("getenv", "CONDA_DEFAULT_ENV").Return(tc.CondaDefaultEnvName)
env.On("getenv", "PYENV_VERSION").Return(tc.PyEnvName)
env.On("getPathSeperator", nil).Return("")
env.On("getcwd", nil).Return("/usr/home/project")
env.On("homeDir", nil).Return("/usr/home")
env.On("getPathSeperator").Return("")
env.On("getcwd").Return("/usr/home/project")
env.On("homeDir").Return("/usr/home")
env.onTemplate()
props := properties{
FetchVersion: tc.FetchVersion,

6
src/segment_dotnet_test.go
View file

@ -25,9 +25,9 @@ func bootStrapDotnetTest(args *dotnetArgs) *dotnet {
}
env.On("hasFiles", "*.cs").Return(true)
env.On("getPathSeperator", nil).Return("")
env.On("getcwd", nil).Return("/usr/home/project")
env.On("homeDir", nil).Return("/usr/home")
env.On("getPathSeperator").Return("")
env.On("getcwd").Return("/usr/home/project")
env.On("homeDir").Return("/usr/home")
env.onTemplate()
props := properties{
FetchVersion: args.displayVersion,

12
src/segment_executiontime_test.go
View file

@ -9,7 +9,7 @@ import (
func TestExecutionTimeWriterDefaultThresholdEnabled(t *testing.T) {
env := new(MockedEnvironment)
env.On("executionTime", nil).Return(1337)
env.On("executionTime").Return(1337)
executionTime := &executiontime{
env: env,
props: properties{},
@ -19,7 +19,7 @@ func TestExecutionTimeWriterDefaultThresholdEnabled(t *testing.T) {
func TestExecutionTimeWriterDefaultThresholdDisabled(t *testing.T) {
env := new(MockedEnvironment)
env.On("executionTime", nil).Return(1)
env.On("executionTime").Return(1)
executionTime := &executiontime{
env: env,
props: properties{},
@ -29,7 +29,7 @@ func TestExecutionTimeWriterDefaultThresholdDisabled(t *testing.T) {
func TestExecutionTimeWriterCustomThresholdEnabled(t *testing.T) {
env := new(MockedEnvironment)
env.On("executionTime", nil).Return(99)
env.On("executionTime").Return(99)
props := properties{
ThresholdProperty: float64(10),
}
@ -42,7 +42,7 @@ func TestExecutionTimeWriterCustomThresholdEnabled(t *testing.T) {
func TestExecutionTimeWriterCustomThresholdDisabled(t *testing.T) {
env := new(MockedEnvironment)
env.On("executionTime", nil).Return(99)
env.On("executionTime").Return(99)
props := properties{
ThresholdProperty: float64(100),
}
@ -57,7 +57,7 @@ func TestExecutionTimeWriterDuration(t *testing.T) {
input := 1337
expected := "1.337s"
env := new(MockedEnvironment)
env.On("executionTime", nil).Return(input)
env.On("executionTime").Return(input)
executionTime := &executiontime{
env: env,
props: properties{},
@ -70,7 +70,7 @@ func TestExecutionTimeWriterDuration2(t *testing.T) {
input := 13371337
expected := "3h 42m 51.337s"
env := new(MockedEnvironment)
env.On("executionTime", nil).Return(input)
env.On("executionTime").Return(input)
executionTime := &executiontime{
env: env,
props: properties{},

4
src/segment_exit_test.go
View file

@ -18,7 +18,7 @@ func TestExitWriterEnabled(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("lastErrorCode", nil).Return(tc.ExitCode)
env.On("lastErrorCode").Return(tc.ExitCode)
e := &exit{
env: env,
props: properties{},
@ -76,7 +76,7 @@ func TestExitWriterTemplateString(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("lastErrorCode", nil).Return(tc.ExitCode)
env.On("lastErrorCode").Return(tc.ExitCode)
env.onTemplate()
props := properties{
SegmentTemplate: tc.Template,

60
src/segment_git_test.go
View file

@ -15,10 +15,10 @@ const (
func TestEnabledGitNotFound(t *testing.T) {
env := new(MockedEnvironment)
env.On("inWSLSharedDrive", nil).Return(false)
env.On("inWSLSharedDrive").Return(false)
env.On("hasCommand", "git").Return(false)
env.On("getRuntimeGOOS", nil).Return("")
env.On("isWsl", nil).Return(false)
env.On("getRuntimeGOOS").Return("")
env.On("isWsl").Return(false)
g := &git{
scm: scm{
env: env,
@ -30,10 +30,10 @@ func TestEnabledGitNotFound(t *testing.T) {
func TestEnabledInWorkingDirectory(t *testing.T) {
env := new(MockedEnvironment)
env.On("inWSLSharedDrive", nil).Return(false)
env.On("inWSLSharedDrive").Return(false)
env.On("hasCommand", "git").Return(true)
env.On("getRuntimeGOOS", nil).Return("")
env.On("isWsl", nil).Return(false)
env.On("getRuntimeGOOS").Return("")
env.On("isWsl").Return(false)
fileInfo := &fileInfo{
path: "/dir/hello",
parentFolder: "/dir",
@ -52,10 +52,10 @@ func TestEnabledInWorkingDirectory(t *testing.T) {
func TestEnabledInWorkingTree(t *testing.T) {
env := new(MockedEnvironment)
env.On("inWSLSharedDrive", nil).Return(false)
env.On("inWSLSharedDrive").Return(false)
env.On("hasCommand", "git").Return(true)
env.On("getRuntimeGOOS", nil).Return("")
env.On("isWsl", nil).Return(false)
env.On("getRuntimeGOOS").Return("")
env.On("isWsl").Return(false)
fileInfo := &fileInfo{
path: "/dev/folder_worktree/.git",
parentFolder: "/dev/folder_worktree",
@ -77,10 +77,10 @@ func TestEnabledInWorkingTree(t *testing.T) {
func TestEnabledInSubmodule(t *testing.T) {
env := new(MockedEnvironment)
env.On("inWSLSharedDrive", nil).Return(false)
env.On("inWSLSharedDrive").Return(false)
env.On("hasCommand", "git").Return(true)
env.On("getRuntimeGOOS", nil).Return("")
env.On("isWsl", nil).Return(false)
env.On("getRuntimeGOOS").Return("")
env.On("isWsl").Return(false)
fileInfo := &fileInfo{
path: "/dev/parent/test-submodule/.git",
parentFolder: "/dev/parent/test-submodule",
@ -106,9 +106,9 @@ func TestGetGitOutputForCommand(t *testing.T) {
commandArgs := []string{"symbolic-ref", "--short", "HEAD"}
want := "je suis le output"
env := new(MockedEnvironment)
env.On("isWsl", nil).Return(false)
env.On("isWsl").Return(false)
env.On("runCommand", "git", append(args, commandArgs...)).Return(want, nil)
env.On("getRuntimeGOOS", nil).Return("unix")
env.On("getRuntimeGOOS").Return("unix")
g := &git{
scm: scm{
env: env,
@ -228,9 +228,9 @@ func TestSetGitHEADContextClean(t *testing.T) {
}
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("inWSLSharedDrive", nil).Return(false)
env.On("getRuntimeGOOS", nil).Return("unix")
env.On("isWsl", nil).Return(false)
env.On("inWSLSharedDrive").Return(false)
env.On("getRuntimeGOOS").Return("unix")
env.On("isWsl").Return(false)
env.mockGitCommand("", "describe", "--tags", "--exact-match")
env.mockGitCommand(tc.Theirs, "name-rev", "--name-only", "--exclude=tags/*", tc.Theirs)
env.mockGitCommand(tc.Ours, "name-rev", "--name-only", "--exclude=tags/*", tc.Ours)
@ -297,8 +297,8 @@ func TestSetPrettyHEADName(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getFileContent", "/HEAD").Return(tc.HEAD)
env.On("getRuntimeGOOS", nil).Return("unix")
env.On("isWsl", nil).Return(false)
env.On("getRuntimeGOOS").Return("unix")
env.On("isWsl").Return(false)
env.mockGitCommand(tc.Tag, "describe", "--tags", "--exact-match")
g := &git{
scm: scm{
@ -414,8 +414,8 @@ func TestSetGitStatus(t *testing.T) {
}
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getRuntimeGOOS", nil).Return("unix")
env.On("isWsl", nil).Return(false)
env.On("getRuntimeGOOS").Return("unix")
env.On("isWsl").Return(false)
env.mockGitCommand(strings.ReplaceAll(tc.Output, "\t", ""), "status", "-unormal", "--branch", "--porcelain=2")
g := &git{
scm: scm{
@ -477,10 +477,10 @@ func TestGitUpstream(t *testing.T) {
}
for _, tc := range cases {
env := &MockedEnvironment{}
env.On("isWsl", nil).Return(false)
env.On("isWsl").Return(false)
env.On("runCommand", "git", []string{"-C", "", "--no-optional-locks", "-c", "core.quotepath=false",
"-c", "color.status=false", "remote", "get-url", "origin"}).Return(tc.Upstream, nil)
env.On("getRuntimeGOOS", nil).Return("unix")
env.On("getRuntimeGOOS").Return("unix")
props := properties{
GithubIcon: "GH",
GitlabIcon: "GL",
@ -556,8 +556,8 @@ func TestShouldIgnoreRootRepository(t *testing.T) {
},
}
env := new(MockedEnvironment)
env.On("homeDir", nil).Return("/home/bill")
env.On("getRuntimeGOOS", nil).Return(windowsPlatform)
env.On("homeDir").Return("/home/bill")
env.On("getRuntimeGOOS").Return(windowsPlatform)
git := &git{
scm: scm{
props: props,
@ -588,9 +588,9 @@ func TestGetGitCommand(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("isWsl", nil).Return(tc.IsWSL)
env.On("getRuntimeGOOS", nil).Return(tc.GOOS)
env.On("getcwd", nil).Return(tc.CWD)
env.On("isWsl").Return(tc.IsWSL)
env.On("getRuntimeGOOS").Return(tc.GOOS)
env.On("getcwd").Return(tc.CWD)
wslUname := "5.10.60.1-microsoft-standard-WSL2"
if tc.IsWSL1 {
wslUname = "4.4.0-19041-Microsoft"
@ -602,10 +602,10 @@ func TestGetGitCommand(t *testing.T) {
},
}
if tc.IsWslSharedPath {
env.On("inWSLSharedDrive", nil).Return(true)
env.On("inWSLSharedDrive").Return(true)
g.IsWslSharedPath = tc.IsWslSharedPath
} else {
env.On("inWSLSharedDrive", nil).Return(false)
env.On("inWSLSharedDrive").Return(false)
}
assert.Equal(t, tc.Expected, g.getGitCommand(), tc.Case)
}

4
src/segment_golang_test.go
View file

@ -21,8 +21,8 @@ func getMockedLanguageEnv(params *mockedLanguageParams) (*MockedEnvironment, pro
env.On("hasCommand", params.cmd).Return(true)
env.On("runCommand", params.cmd, []string{params.versionParam}).Return(params.versionOutput, nil)
env.On("hasFiles", params.extension).Return(true)
env.On("getcwd", nil).Return("/usr/home/project")
env.On("homeDir", nil).Return("/usr/home")
env.On("getcwd").Return("/usr/home/project")
env.On("homeDir").Return("/usr/home")
env.onTemplate()
props := properties{
FetchVersion: true,

4
src/segment_java_test.go
View file

@ -57,8 +57,8 @@ func TestJava(t *testing.T) {
env.On("hasCommand", "java").Return(true)
env.On("runCommand", "java", []string{"-Xinternalversion"}).Return(tc.Version, nil)
env.On("hasFiles", "pom.xml").Return(true)
env.On("getcwd", nil).Return("/usr/home/project")
env.On("homeDir", nil).Return("/usr/home")
env.On("getcwd").Return("/usr/home/project")
env.On("homeDir").Return("/usr/home")
if tc.JavaHomeEnabled {
env.On("getenv", "JAVA_HOME").Return("/usr/java")
env.On("hasCommand", "/usr/java/bin/java").Return(true)

2
src/segment_kubectl_test.go
View file

@ -124,7 +124,7 @@ func TestKubectlSegment(t *testing.T) {
for path, content := range tc.Files {
env.On("getFileContent", path).Return(content)
}
env.On("homeDir", nil).Return("testhome")
env.On("homeDir").Return("testhome")
env.onTemplate()
k := &kubectl{

4
src/segment_language_test.go
View file

@ -48,8 +48,8 @@ func bootStrapLanguageTest(args *languageArgs) *language {
if args.inHome {
cwd = home
}
env.On("getcwd", nil).Return(cwd)
env.On("homeDir", nil).Return(home)
env.On("getcwd").Return(cwd)
env.On("homeDir").Return(home)
env.onTemplate()
if args.properties == nil {
args.properties = properties{}

2
src/segment_nightscout_test.go
View file

@ -140,7 +140,7 @@ func TestNSSegment(t *testing.T) {
cache.On("set", FAKEAPIURL, tc.JSONResponse, tc.CacheTimeout).Return()
env.On("HTTPRequest", FAKEAPIURL).Return([]byte(tc.JSONResponse), tc.Error)
env.On("cache", nil).Return(cache)
env.On("cache").Return(cache)
env.onTemplate()
if tc.Template != "" {

4
src/segment_os_test.go
View file

@ -61,9 +61,9 @@ func TestOSInfo(t *testing.T) {
}
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getRuntimeGOOS", nil).Return(tc.GOOS)
env.On("getRuntimeGOOS").Return(tc.GOOS)
env.On("getenv", "WSL_DISTRO_NAME").Return(tc.WSLDistro)
env.On("getPlatform", nil).Return(tc.Platform)
env.On("getPlatform").Return(tc.Platform)
osInfo := &osInfo{
env: env,
props: properties{

4
src/segment_owm_test.go
View file

@ -245,7 +245,7 @@ func TestOWMSegmentFromCache(t *testing.T) {
cache.On("get", "owm_response").Return(response, true)
cache.On("get", "owm_url").Return("http://api.openweathermap.org/data/2.5/weather?q=AMSTERDAM,NL&units=metric&appid=key", true)
cache.On("set").Return()
env.On("cache", nil).Return(cache)
env.On("cache").Return(cache)
env.onTemplate()
assert.Nil(t, o.setStatus())
@ -272,7 +272,7 @@ func TestOWMSegmentFromCacheWithHyperlink(t *testing.T) {
cache.On("get", "owm_response").Return(response, true)
cache.On("get", "owm_url").Return("http://api.openweathermap.org/data/2.5/weather?q=AMSTERDAM,NL&units=metric&appid=key", true)
cache.On("set").Return()
env.On("cache", nil).Return(cache)
env.On("cache").Return(cache)
env.onTemplate()
assert.Nil(t, o.setStatus())

154
src/segment_path_test.go
View file

@ -20,12 +20,12 @@ func (env *MockedEnvironment) getenv(key string) string {
}
func (env *MockedEnvironment) getcwd() string {
args := env.Called(nil)
args := env.Called()
return args.String(0)
}
func (env *MockedEnvironment) homeDir() string {
args := env.Called(nil)
args := env.Called()
return args.String(0)
}
@ -55,27 +55,27 @@ func (env *MockedEnvironment) getFoldersList(path string) []string {
}
func (env *MockedEnvironment) getPathSeperator() string {
args := env.Called(nil)
args := env.Called()
return args.String(0)
}
func (env *MockedEnvironment) getCurrentUser() string {
args := env.Called(nil)
args := env.Called()
return args.String(0)
}
func (env *MockedEnvironment) getHostName() (string, error) {
args := env.Called(nil)
args := env.Called()
return args.String(0), args.Error(1)
}
func (env *MockedEnvironment) getRuntimeGOOS() string {
args := env.Called(nil)
args := env.Called()
return args.String(0)
}
func (env *MockedEnvironment) getPlatform() string {
args := env.Called(nil)
args := env.Called()
return args.String(0)
}
@ -95,32 +95,32 @@ func (env *MockedEnvironment) runShellCommand(shell, command string) string {
}
func (env *MockedEnvironment) lastErrorCode() int {
args := env.Called(nil)
args := env.Called()
return args.Int(0)
}
func (env *MockedEnvironment) executionTime() float64 {
args := env.Called(nil)
args := env.Called()
return float64(args.Int(0))
}
func (env *MockedEnvironment) isRunningAsRoot() bool {
args := env.Called(nil)
args := env.Called()
return args.Bool(0)
}
func (env *MockedEnvironment) getArgs() *args {
arguments := env.Called(nil)
arguments := env.Called()
return arguments.Get(0).(*args)
}
func (env *MockedEnvironment) getBatteryInfo() ([]*battery.Battery, error) {
args := env.Called(nil)
args := env.Called()
return args.Get(0).([]*battery.Battery), args.Error(1)
}
func (env *MockedEnvironment) getShellName() string {
args := env.Called(nil)
args := env.Called()
return args.String(0)
}
@ -145,61 +145,61 @@ func (env *MockedEnvironment) hasParentFilePath(path string) (*fileInfo, error)
}
func (env *MockedEnvironment) stackCount() int {
args := env.Called(nil)
args := env.Called()
return args.Int(0)
}
func (env *MockedEnvironment) isWsl() bool {
args := env.Called(nil)
args := env.Called()
return args.Bool(0)
}
func (env *MockedEnvironment) isWsl2() bool {
args := env.Called(nil)
args := env.Called()
return args.Bool(0)
}
func (env *MockedEnvironment) getTerminalWidth() (int, error) {
args := env.Called(nil)
args := env.Called()
return args.Int(0), args.Error(1)
}
func (env *MockedEnvironment) getCachePath() string {
args := env.Called(nil)
args := env.Called()
return args.String(0)
}
func (env *MockedEnvironment) cache() cache {
args := env.Called(nil)
args := env.Called()
return args.Get(0).(cache)
}
func (env *MockedEnvironment) close() {
_ = env.Called(nil)
_ = env.Called()
}
func (env *MockedEnvironment) logs() string {
args := env.Called(nil)
args := env.Called()
return args.String(0)
}
func (env *MockedEnvironment) inWSLSharedDrive() bool {
args := env.Called(nil)
args := env.Called()
return args.Bool(0)
}
func (env *MockedEnvironment) convertToWindowsPath(path string) string {
args := env.Called(nil)
args := env.Called()
return args.String(0)
}
func (env *MockedEnvironment) convertToLinuxPath(path string) string {
args := env.Called(nil)
args := env.Called()
return args.String(0)
}
func (env *MockedEnvironment) getWifiNetwork() (*wifiInfo, error) {
args := env.Called(nil)
args := env.Called()
return args.Get(0).(*wifiInfo), args.Error(1)
}
@ -210,7 +210,7 @@ func (env *MockedEnvironment) onTemplate() {
return
}
}
env.On(method, nil).Return(returnArguments...)
env.On(method).Return(returnArguments...)
}
patchMethodIfNotSpecified("isRunningAsRoot", false)
patchMethodIfNotSpecified("getcwd", "/usr/home/dev/my-app")
@ -232,7 +232,7 @@ const (
func TestIsInHomeDirTrue(t *testing.T) {
home := homeBill
env := new(MockedEnvironment)
env.On("homeDir", nil).Return(home)
env.On("homeDir").Return(home)
path := &path{
env: env,
}
@ -247,7 +247,7 @@ func TestIsInHomeDirLevelTrue(t *testing.T) {
pwd += levelDir
}
env := new(MockedEnvironment)
env.On("homeDir", nil).Return(home)
env.On("homeDir").Return(home)
path := &path{
env: env,
}
@ -276,14 +276,14 @@ func TestRootLocationHome(t *testing.T) {
}
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("homeDir", nil).Return(tc.HomePath)
env.On("getcwd", nil).Return(tc.Pwd)
env.On("homeDir").Return(tc.HomePath)
env.On("getcwd").Return(tc.Pwd)
args := &args{
PSWD: &tc.Pswd,
}
env.On("getArgs", nil).Return(args)
env.On("getPathSeperator", nil).Return(tc.PathSeperator)
env.On("getRuntimeGOOS", nil).Return("")
env.On("getArgs").Return(args)
env.On("getPathSeperator").Return(tc.PathSeperator)
env.On("getRuntimeGOOS").Return("")
path := &path{
env: env,
props: properties{
@ -299,7 +299,7 @@ func TestRootLocationHome(t *testing.T) {
func TestIsInHomeDirFalse(t *testing.T) {
home := homeBill
env := new(MockedEnvironment)
env.On("homeDir", nil).Return(home)
env.On("homeDir").Return(home)
path := &path{
env: env,
}
@ -313,8 +313,8 @@ func TestPathDepthMultipleLevelsDeep(t *testing.T) {
pwd += levelDir
}
env := new(MockedEnvironment)
env.On("getPathSeperator", nil).Return("/")
env.On("getRunteGOOS", nil).Return("")
env.On("getPathSeperator").Return("/")
env.On("getRunteGOOS").Return("")
path := &path{
env: env,
}
@ -325,7 +325,7 @@ func TestPathDepthMultipleLevelsDeep(t *testing.T) {
func TestPathDepthZeroLevelsDeep(t *testing.T) {
pwd := "/usr/"
env := new(MockedEnvironment)
env.On("getPathSeperator", nil).Return("/")
env.On("getPathSeperator").Return("/")
path := &path{
env: env,
}
@ -336,7 +336,7 @@ func TestPathDepthZeroLevelsDeep(t *testing.T) {
func TestPathDepthOneLevelDeep(t *testing.T) {
pwd := "/usr/location"
env := new(MockedEnvironment)
env.On("getPathSeperator", nil).Return("/")
env.On("getPathSeperator").Return("/")
path := &path{
env: env,
}
@ -427,15 +427,15 @@ func TestAgnosterPathStyles(t *testing.T) {
}
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getPathSeperator", nil).Return(tc.PathSeperator)
env.On("homeDir", nil).Return(tc.HomePath)
env.On("getcwd", nil).Return(tc.Pwd)
env.On("getRuntimeGOOS", nil).Return(tc.GOOS)
env.On("stackCount", nil).Return(0)
env.On("getPathSeperator").Return(tc.PathSeperator)
env.On("homeDir").Return(tc.HomePath)
env.On("getcwd").Return(tc.Pwd)
env.On("getRuntimeGOOS").Return(tc.GOOS)
env.On("stackCount").Return(0)
args := &args{
PSWD: &tc.Pswd,
}
env.On("getArgs", nil).Return(args)
env.On("getArgs").Return(args)
env.onTemplate()
path := &path{
env: env,
@ -548,15 +548,15 @@ func TestGetFullPath(t *testing.T) {
if len(tc.PathSeparator) == 0 {
tc.PathSeparator = "/"
}
env.On("getPathSeperator", nil).Return(tc.PathSeparator)
env.On("homeDir", nil).Return("/usr/home")
env.On("getcwd", nil).Return(tc.Pwd)
env.On("getRuntimeGOOS", nil).Return(tc.GOOS)
env.On("stackCount", nil).Return(tc.StackCount)
env.On("getPathSeperator").Return(tc.PathSeparator)
env.On("homeDir").Return("/usr/home")
env.On("getcwd").Return(tc.Pwd)
env.On("getRuntimeGOOS").Return(tc.GOOS)
env.On("stackCount").Return(tc.StackCount)
args := &args{
PSWD: &tc.Pswd,
}
env.On("getArgs", nil).Return(args)
env.On("getArgs").Return(args)
env.onTemplate()
if len(tc.Template) == 0 {
tc.Template = "{{ if gt .StackCount 0 }}{{ .StackCount }} {{ end }}{{ .Path }}"
@ -599,14 +599,14 @@ func TestGetFullPathCustomMappedLocations(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getPathSeperator", nil).Return("/")
env.On("homeDir", nil).Return("/usr/home")
env.On("getcwd", nil).Return(tc.Pwd)
env.On("getRuntimeGOOS", nil).Return("")
env.On("getPathSeperator").Return("/")
env.On("homeDir").Return("/usr/home")
env.On("getcwd").Return(tc.Pwd)
env.On("getRuntimeGOOS").Return("")
args := &args{
PSWD: &tc.Pwd,
}
env.On("getArgs", nil).Return(args)
env.On("getArgs").Return(args)
path := &path{
env: env,
props: properties{
@ -637,8 +637,8 @@ func TestNormalizePath(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("homeDir", nil).Return("/usr/home")
env.On("getRuntimeGOOS", nil).Return(tc.GOOS)
env.On("homeDir").Return("/usr/home")
env.On("getRuntimeGOOS").Return(tc.GOOS)
pt := &path{
env: env,
}
@ -650,14 +650,14 @@ func TestNormalizePath(t *testing.T) {
func TestGetFolderPathCustomMappedLocations(t *testing.T) {
pwd := "/a/b/c/d"
env := new(MockedEnvironment)
env.On("getPathSeperator", nil).Return("/")
env.On("homeDir", nil).Return("/usr/home")
env.On("getcwd", nil).Return(pwd)
env.On("getRuntimeGOOS", nil).Return("")
env.On("getPathSeperator").Return("/")
env.On("homeDir").Return("/usr/home")
env.On("getcwd").Return(pwd)
env.On("getRuntimeGOOS").Return("")
args := &args{
PSWD: &pwd,
}
env.On("getArgs", nil).Return(args)
env.On("getArgs").Return(args)
path := &path{
env: env,
props: properties{
@ -697,14 +697,14 @@ func TestAgnosterPath(t *testing.T) { // nolint:dupl
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("homeDir", nil).Return(tc.Home)
env.On("getPathSeperator", nil).Return(tc.PathSeparator)
env.On("getcwd", nil).Return(tc.PWD)
env.On("getRuntimeGOOS", nil).Return("")
env.On("homeDir").Return(tc.Home)
env.On("getPathSeperator").Return(tc.PathSeparator)
env.On("getcwd").Return(tc.PWD)
env.On("getRuntimeGOOS").Return("")
args := &args{
PSWD: &tc.PWD,
}
env.On("getArgs", nil).Return(args)
env.On("getArgs").Return(args)
path := &path{
env: env,
props: properties{
@ -745,14 +745,14 @@ func TestAgnosterLeftPath(t *testing.T) { // nolint:dupl
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("homeDir", nil).Return(tc.Home)
env.On("getPathSeperator", nil).Return(tc.PathSeparator)
env.On("getcwd", nil).Return(tc.PWD)
env.On("getRuntimeGOOS", nil).Return("")
env.On("homeDir").Return(tc.Home)
env.On("getPathSeperator").Return(tc.PathSeparator)
env.On("getcwd").Return(tc.PWD)
env.On("getRuntimeGOOS").Return("")
args := &args{
PSWD: &tc.PWD,
}
env.On("getArgs", nil).Return(args)
env.On("getArgs").Return(args)
path := &path{
env: env,
props: properties{
@ -793,14 +793,14 @@ func TestGetPwd(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getPathSeperator", nil).Return("/")
env.On("homeDir", nil).Return("/usr/home")
env.On("getcwd", nil).Return(tc.Pwd)
env.On("getRuntimeGOOS", nil).Return("")
env.On("getPathSeperator").Return("/")
env.On("homeDir").Return("/usr/home")
env.On("getcwd").Return(tc.Pwd)
env.On("getRuntimeGOOS").Return("")
args := &args{
PSWD: &tc.Pswd,
}
env.On("getArgs", nil).Return(args)
env.On("getArgs").Return(args)
path := &path{
env: env,
props: properties{

8
src/segment_plastic_test.go
View file

@ -9,8 +9,8 @@ import (
func TestPlasticEnabledNotFound(t *testing.T) {
env := new(MockedEnvironment)
env.On("hasCommand", "cm").Return(false)
env.On("getRuntimeGOOS", nil).Return("")
env.On("isWsl", nil).Return(false)
env.On("getRuntimeGOOS").Return("")
env.On("isWsl").Return(false)
p := &plastic{
scm: scm{
env: env,
@ -23,8 +23,8 @@ func TestPlasticEnabledNotFound(t *testing.T) {
func TestPlasticEnabledInWorkspaceDirectory(t *testing.T) {
env := new(MockedEnvironment)
env.On("hasCommand", "cm").Return(true)
env.On("getRuntimeGOOS", nil).Return("")
env.On("isWsl", nil).Return(false)
env.On("getRuntimeGOOS").Return("")
env.On("isWsl").Return(false)
fileInfo := &fileInfo{
path: "/dir/hello",
parentFolder: "/dir",

8
src/segment_python_test.go
View file

@ -49,9 +49,9 @@ func TestPythonTemplate(t *testing.T) {
env.On("getenv", "CONDA_ENV_PATH").Return(tc.VirtualEnvName)
env.On("getenv", "CONDA_DEFAULT_ENV").Return(tc.VirtualEnvName)
env.On("getenv", "PYENV_VERSION").Return(tc.VirtualEnvName)
env.On("getPathSeperator", nil).Return("")
env.On("getcwd", nil).Return("/usr/home/project")
env.On("homeDir", nil).Return("/usr/home")
env.On("getPathSeperator").Return("")
env.On("getcwd").Return("/usr/home/project")
env.On("homeDir").Return("/usr/home")
env.onTemplate()
props := properties{
FetchVersion: tc.FetchVersion,
@ -76,7 +76,7 @@ func TestPythonPythonInContext(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getPathSeperator", nil).Return("")
env.On("getPathSeperator").Return("")
env.On("getenv", "VIRTUAL_ENV").Return(tc.VirtualEnvName)
env.On("getenv", "CONDA_ENV_PATH").Return("")
env.On("getenv", "CONDA_DEFAULT_ENV").Return("")

4
src/segment_ruby_test.go
View file

@ -96,8 +96,8 @@ func TestRuby(t *testing.T) {
env.On("hasFiles", "*.rb").Return(tc.HasRubyFiles)
env.On("hasFiles", "Rakefile").Return(tc.HasRakeFile)
env.On("hasFiles", "Gemfile").Return(tc.HasGemFile)
env.On("getcwd", nil).Return("/usr/home/project")
env.On("homeDir", nil).Return("/usr/home")
env.On("getcwd").Return("/usr/home/project")
env.On("homeDir").Return("/usr/home")
env.onTemplate()
props := properties{
FetchVersion: tc.FetchVersion,

8
src/segment_session_test.go
View file

@ -96,16 +96,16 @@ func TestSessionSegmentTemplate(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getCurrentUser", nil).Return(tc.UserName)
env.On("getRuntimeGOOS", nil).Return("burp")
env.On("getHostName", nil).Return(tc.ComputerName, nil)
env.On("getCurrentUser").Return(tc.UserName)
env.On("getRuntimeGOOS").Return("burp")
env.On("getHostName").Return(tc.ComputerName, nil)
var SSHSession string
if tc.SSHSession {
SSHSession = "zezzion"
}
env.On("getenv", "SSH_CONNECTION").Return(SSHSession)
env.On("getenv", "SSH_CLIENT").Return(SSHSession)
env.On("isRunningAsRoot", nil).Return(tc.Root)
env.On("isRunningAsRoot").Return(tc.Root)
env.On("getenv", defaultUserEnvVar).Return(tc.DefaultUserName)
env.onTemplate()
session := &session{

4
src/segment_shell_test.go
View file

@ -9,7 +9,7 @@ import (
func TestWriteCurrentShell(t *testing.T) {
expected := "zsh"
env := new(MockedEnvironment)
env.On("getShellName", nil).Return(expected, nil)
env.On("getShellName").Return(expected, nil)
s := &shell{
env: env,
props: properties{},
@ -28,7 +28,7 @@ func TestUseMappedShellNames(t *testing.T) {
}
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getShellName", nil).Return(tc.Expected, nil)
env.On("getShellName").Return(tc.Expected, nil)
s := &shell{
env: env,
props: properties{

2
src/segment_spotify_wsl_test.go
View file

@ -52,7 +52,7 @@ func TestSpotifyWsl(t *testing.T) {
}
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("isWsl", nil).Return(true)
env.On("isWsl").Return(true)
env.On("runCommand", "tasklist.exe", []string{"/V", "/FI", "Imagename eq Spotify.exe", "/FO", "CSV", "/NH"}).Return(tc.ExecOutput, nil)
s := &spotify{
env: env,

2
src/segment_strava_test.go
View file

@ -153,7 +153,7 @@ func TestStravaSegment(t *testing.T) {
env.On("HTTPRequest", url).Return([]byte(tc.JSONResponse), tc.Error)
env.On("HTTPRequest", tokenURL).Return([]byte(tc.TokenResponse), tc.Error)
env.On("cache", nil).Return(cache)
env.On("cache").Return(cache)
env.onTemplate()
if tc.Template != "" {

2
src/segment_terraform_test.go
View file

@ -16,7 +16,7 @@ func bootStrapTerraformTest(args *terraformArgs) *terraform {
env := new(MockedEnvironment)
env.On("hasCommand", "terraform").Return(args.hasTfCommand)
env.On("hasFolder", "/.terraform").Return(args.hasTfFolder)
env.On("getcwd", nil).Return("")
env.On("getcwd").Return("")
env.On("runCommand", "terraform", []string{"workspace", "show"}).Return(args.workspaceName, nil)
env.onTemplate()
k := &terraform{

18
src/segment_test.go
View file

@ -80,9 +80,9 @@ func TestShouldIncludeFolder(t *testing.T) {
}
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getRuntimeGOOS", nil).Return(linuxPlatform)
env.On("homeDir", nil).Return("")
env.On("getcwd", nil).Return(cwd)
env.On("getRuntimeGOOS").Return(linuxPlatform)
env.On("homeDir").Return("")
env.On("getcwd").Return(cwd)
segment := &Segment{
Properties: properties{
IncludeFolders: tc.IncludeFolders,
@ -97,9 +97,9 @@ func TestShouldIncludeFolder(t *testing.T) {
func TestShouldIncludeFolderRegexInverted(t *testing.T) {
env := new(MockedEnvironment)
env.On("getRuntimeGOOS", nil).Return(linuxPlatform)
env.On("homeDir", nil).Return("")
env.On("getcwd", nil).Return(cwd)
env.On("getRuntimeGOOS").Return(linuxPlatform)
env.On("homeDir").Return("")
env.On("getcwd").Return(cwd)
segment := &Segment{
Properties: properties{
ExcludeFolders: []string{"(?!Projects[\\/]).*"},
@ -118,9 +118,9 @@ func TestShouldIncludeFolderRegexInverted(t *testing.T) {
func TestShouldIncludeFolderRegexInvertedNonEscaped(t *testing.T) {
env := new(MockedEnvironment)
env.On("getRuntimeGOOS", nil).Return(linuxPlatform)
env.On("homeDir", nil).Return("")
env.On("getcwd", nil).Return(cwd)
env.On("getRuntimeGOOS").Return(linuxPlatform)
env.On("homeDir").Return("")
env.On("getcwd").Return(cwd)
segment := &Segment{
Properties: properties{
ExcludeFolders: []string{"(?!Projects/).*"},

14
src/segment_text_test.go
View file

@ -24,15 +24,15 @@ func TestTextSegment(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getcwd", nil).Return("/usr/home/posh")
env.On("homeDir", nil).Return("/usr/home")
env.On("getPathSeperator", nil).Return("/")
env.On("isRunningAsRoot", nil).Return(true)
env.On("getShellName", nil).Return("terminal")
env.On("getcwd").Return("/usr/home/posh")
env.On("homeDir").Return("/usr/home")
env.On("getPathSeperator").Return("/")
env.On("isRunningAsRoot").Return(true)
env.On("getShellName").Return("terminal")
env.On("getenv", "HELLO").Return("hello")
env.On("getenv", "WORLD").Return("")
env.On("getCurrentUser", nil).Return("Posh")
env.On("getHostName", nil).Return("MyHost", nil)
env.On("getCurrentUser").Return("Posh")
env.On("getHostName").Return("MyHost", nil)
env.onTemplate()
txt := &text{
env: env,

2
src/segment_wakatime_test.go
View file

@ -76,7 +76,7 @@ func TestWTTrackedTime(t *testing.T) {
cache := &MockedCache{}
cache.On("get", FAKEAPIURL).Return(response, !tc.CacheFoundFail)
cache.On("set", FAKEAPIURL, response, tc.CacheTimeout).Return()
env.On("cache", nil).Return(cache)
env.On("cache").Return(cache)
env.onTemplate()
w := &wakatime{

6
src/segment_wifi_test.go
View file

@ -42,9 +42,9 @@ func TestWiFiSegment(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getPlatform", nil).Return(windowsPlatform)
env.On("isWsl", nil).Return(false)
env.On("getWifiNetwork", nil).Return(tc.Network, tc.WifiError)
env.On("getPlatform").Return(windowsPlatform)
env.On("isWsl").Return(false)
env.On("getWifiNetwork").Return(tc.Network, tc.WifiError)
env.onTemplate()
w := &wifi{

2
src/segment_winreg_test.go
View file

@ -71,7 +71,7 @@ func TestWinReg(t *testing.T) {
for _, tc := range cases {
env := new(MockedEnvironment)
env.On("getRuntimeGOOS", nil).Return(windowsPlatform)
env.On("getRuntimeGOOS").Return(windowsPlatform)
env.On("getWindowsRegistryKeyValue", tc.Path).Return(tc.getWRKVOutput, tc.Err)
env.onTemplate()
r := &winreg{

2
src/template_test.go
View file

@ -121,10 +121,10 @@ func TestRenderTemplateEnvVar(t *testing.T) {
}
for _, tc := range cases {
env := &MockedEnvironment{}
env.onTemplate()
for name, value := range tc.Env {
env.On("getenv", name).Return(value)
}
env.onTemplate()
template := &textTemplate{
Template: tc.Template,
Context: tc.Context,