How to import go modules into /*_test.go files?

How do I import my functions into my testing folder? I ran go mod init in the cmd directory and it created a go.mod file with module "cmd", however when I try to import it in testing, I'm unable to access to functions. I am running go test ./test in root project directory and error is: test/services_test.go:4:2: "cmd" is not an importable package;

myproject
├── cmd
     ├── main.go (package main)
     ├── helper.go (package main)
     └── services.go (package main)
├── test
     ├── helper_test.go (package_main)
     └── services_test.go (package main)
├── go.mod (module cmd)
└── go.sum

In cmd/services.go

package main

func doStuff() { 
  // TODO
}

In test/services_test.go

package main

import {
    "cmd"
    "testing"
}

func TestdoStuff (*testing.T) {
    cmd.doStuff()
}

The tests for a given package should be in that package so that they can see unexported variables, fields, and methods of that package, and don't need to import that package at all. Don't put them in a separate test directory.

You can import other packages if necessary to test this one, but you won't be able to see unexported stuff from other packages. Tests are no different from any other file in that regard.

As pointed out in others answers, test files have to be in the same directory as the tested file.
You can check out the tutorial Create a Go Module and then Add a Test.

Here are the examples from these tutorials:

myproject
├── greetings
     ├── greetings.go (package greetings)
     ├── greetings_test.go (package greetings)
├── go.mod
└── go.sum

The greetings.go file:

package greetings

import "fmt"

// Hello returns a greeting for the named person.
func Hello(name string) string {
    // Return a greeting that embeds the name in a message.
    message := fmt.Sprintf("Hi, %v. Welcome!", name)
    return message
}

And greetings_test.go file with two tests:

package greetings

import (
    "testing"
    "regexp"
)

// TestHelloName calls greetings.Hello with a name, checking
// for a valid return value.
func TestHelloName(t *testing.T) {
    name := "Gladys"
    want := regexp.MustCompile(`\b`+name+`\b`)
    msg, err := Hello("Gladys")
    if !want.MatchString(msg) || err != nil {
        t.Fatalf(`Hello("Gladys") = %q, %v, want match for %#q, nil`, msg, err, want)
    }
}

// TestHelloEmpty calls greetings.Hello with an empty string,
// checking for an error.
func TestHelloEmpty(t *testing.T) {
    msg, err := Hello("")
    if msg != "" || err == nil {
        t.Fatalf(`Hello("") = %q, %v, want "", error`, msg, err)
    }
}

The compiled artifact for a package main is a binary, and that binary is what downstream users of the package will interact with. So a test that verifies the behavior of package main should test against the binary itself, not the individual functions used to implement that binary.

You can write such a test by using the os/exec package to run go build cmd (perhaps using the -o flag to output the binary to the test's temporary directory), then using the os/exec package to execute the resulting binary.

Or, use a third-party testing package such as github.com/rogpeppe/testscript to write more concise script-driven tests.

Or, factor out any helper-functions into internal packages and test the exported functions of those packages.

With any of those approaches, the tests for a given package still belong in the same directory as that package. That way, when users run go test cmd they can be confident that cmd actually works — if the test is in a different package, they won't obviously know to run go test test in order to test the cmd package.