How to write unit test for a program that contains channels, filewalk and api call in golang?

My program is as follows as a whole.

func main() {
flag.Parse()
if *token == "" {
log.Fatal(Red + "please provide a client token => -token={$token}")
}
tokenSource := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: *token})
oauthClient := oauth2.NewClient(context.TODO(), tokenSource)
client := putio.NewClient(oauthClient)
//paths := make(chan string)
var wg = new(sync.WaitGroup)
for i := 0; i < 50; i++ {
wg.Add(1)
go worker(paths, wg, client)
}
WalkFilePath()
//if err := filepath.Walk(*rootpath, func(path string, info os.FileInfo, err error) error {
//	if err != nil {
//		return fmt.Errorf("Failed to walk directory: %T %w", err, err)
//	}
//	if !info.IsDir() {
//		paths <- path
//	}
//	return nil
//}); err != nil {
//	panic(fmt.Errorf("failed Walk: %w", err))
//}
close(paths)
wg.Wait()
}
// walks the file path and sends paths to channel
func WalkFilePath() {
if err := filepath.Walk(*rootpath, func(path string, info os.FileInfo, err error) error {
if err != nil {
return fmt.Errorf("Failed to walk directory: %T %w", err, err)
}
if !info.IsDir() {
paths <- path
}
return nil
}); err != nil {
panic(fmt.Errorf("failed Walk: %w", err))
}
}
func worker(paths <-chan string, wg *sync.WaitGroup, client *putio.Client) {
defer wg.Done()
for path := range paths {
f, err := os.Open(path)
if err != nil {
log.Printf(Red + "Failed to open file %v for reading" + Reset, f.Name())
}
upload, err := client.Files.Upload(context.TODO(), f, path, 0)
if err != nil {
log.Printf(Red + "Failed to upload file %v" + Reset, upload.File.Name)
}
log.Printf(Green+ "File %v has been uploaded succesfully" + Reset, upload.File.Name)
}
}

I did write the code. That's the cleanest I can do and I was told to write a unit test for the program. I'm confused. For example, considering the WalkFilePath function. What should I provide and what kind of result I should expect to test the function. Because it contains channel communication meaning goroutines. Is there any way to write unit tests for this program clearly? Or should I change the code structure which is not good in this case for me. Btw, the program runs properly.

Like most things, Go is very opinionated about how to test. Make sure to read https://go.dev/doc/tutorial/add-a-test

> For example, considering the WalkFilePath function. What should I provide and what kind of result I should expect to test the function.

The input to WalkFilePath should be paths and a rootpath. Your WalkFilePath doesn't get paths or rootpath from anywhere, so this code wouldn't compile as is (testing will help catch that stuff of course).

A test for WalkFilePath might be done something like this:

1. Create a filesystem structure in your project under testdata/, a directory expressly set aside for data used for testing. Create subdirectories and files. For an example that might look like:

   testdata/
   walktest/
   dir1/
   file1.txt
   dir2/
   file2.txt
   dir3/
   file3.txt
   

2. Now you can define the expected data you'll be getting out of your channel.

   expected_paths := []string{
   "testdata/walktest/dir1/file1.txt",
   "testdata/walktest/dir2/file2.txt",
   "testdata/walktest/dir3/file3.txt"
   }
   

3. Now you need to change WalkFilePath to take arguments for rootpath and paths.

   func WalkFilePath(rootdir string, paths chan<- string) {
   

4. Now you're ready to write your test.

   func TestWalkFilePath(t *testing.T(
   paths := make(chan string)
   go WalkFilePath("testdata/walktest")
   results := make([]string,0)
   for path := range paths {
   results = append(results, path)
   }
   exp, res := strings.Join(expected_paths, ""), strings.Join(results, "")
   if exp != res {
   t.Errorf("Expected %s got %s", exp, res)
   }
   }
   

> Because it contains channel communication meaning goroutines.

It's totally normal and valid to use channels and goroutines in unit tests.