How to write a unit test for Interrupt Signal (Ctrl+C) of an HTTP server?

Question

Given a small HTTP server, how can you write a unit test to make sure the interrupt is dealt with correctly?

package main

import (
    "context"
    "fmt"
    "net"
    "net/http"
    "os"
    "os/signal"
    "syscall"
    "time"
)

func SimpleServer() {
    ctx := context.Background()
    server := http.Server{
        Addr:        ":8080",
        BaseContext: func(net.Listener) context.Context { return ctx },
    }

    http.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
        fmt.Fprint(w, "pong at ", time.Now().String())
    })

    go server.ListenAndServe()

    exitChannel := make(chan os.Signal, 1) // reserve with buffer size 1 so the notifiers aren't blocked
    defer close(exitChannel)
    signal.Notify(exitChannel, os.Interrupt, syscall.SIGTERM) // Docker and Kubernetes will signal with syscall.SIGTERM

    <-exitChannel

    fmt.Print("\n")
    fmt.Println("shutting down server...")

    err := server.Shutdown(ctx)
    fmt.Println(err)
}

I'm wondering how to pass in this:

exitChannel <- syscall.SIGINT

or:

syscall.Kill(syscall.Getpid(), syscall.SIGINT)

..and then somehow be notified that the server shut down.

Update:

Following Burak's answer below, here's a working solution:

func exampleCaller() {
    exitChannel, serverDownChannel := HTTPServer()

    fmt.Println("sending kill signal in...")
    for i := 3; i > 0; i-- {
        fmt.Println(i)
        time.Sleep(1 * time.Second)
    }
    exitChannel <- syscall.SIGINT
    fmt.Println("kill signal sent")

    <-serverDownChannel
    fmt.Println("server is down!")
}

func HTTPServer() (chan os.Signal, chan struct{}) {
    responseDelay := 1000 // millisecond delay before sending a response message

    ctx := context.Background()
    server := http.Server{
        Addr:        ":8080",
        BaseContext: func(net.Listener) context.Context { return ctx },
    }

    http.HandleFunc("/ping", func(w http.ResponseWriter, r *http.Request) {
        time.Sleep(time.Duration(responseDelay) * time.Millisecond)
        fmt.Fprint(w, "pong at ", time.Now().String())
    })

    fmt.Println("creating channels...")
    exitChannel := make(chan os.Signal, 1)                    // reserve with buffer size 1 so the notifiers aren't blocked
    serverDownChannel := make(chan struct{})                  // NOTE: we're not passing any data into this channel
    signal.Notify(exitChannel, os.Interrupt, syscall.SIGTERM) // Docker and Kubernetes will signal with syscall.SIGTERM

    go func() {
        <-exitChannel // wait for the signal interrupt
        fmt.Print("\n")
        fmt.Println("shutting down server...")
        err := server.Shutdown(ctx)
        fmt.Println(err)
    }()

    go func() {
        server.ListenAndServe() // start the HTTP server
        close(serverDownChannel)
    }()

    return exitChannel, serverDownChannel
}

Answer 1

Instead of waiting for a signal and shutting down, you can refactor a bit to shutdown based on a signal:

exitChannel := make(chan struct{}) 
serverDown:=make(chan struct{})
go func() {
   <-exitChannel
   server.Shutdown(ctx)
}()
go func() {
  server.ListenAndServe()
  close(serverDown)
}()
return exitChannel, serverDown

Then, you can use the exitChannel to terminate the server externally, and serverDown to detect if the server shutdown. Hook up the signal channel externally, so when you receive the shutdown signal, you can write to the exitChannel.