Modularizing golang package using interfaces - go

Question

I am learning golang and in the process of trying to wrap my head around interfaces and how to use them for unit testing.
I currently have a main.go which calls another package: packageName that I wrote.
Currently in main.go, I use package like this:
package main
import (
...
./packageName
)
func main () {
var1 := "test"
str1 := packageName.Func1(var1)
var2 := "sample"
str2 := packageName.Func2(var2)
}
and packageName is:
package packageName
import (
"os"
"net/http"
)
func Func1 (str string) string {
resp,err := http.get("www.something.com")
return resp.string() // or something along these lines
}
func Func2 (str string) string {
sampleFile, sampleFileErr := os.OpenFile(str, os.O_CREATE, 0600)
return "done"
}
After reading about testing and interfaces, it seems like I have to rewrite everything using interfaces so it can be unit tested (more modular).
My question, is how do I do this properly. Do I put all external library calls into one interface, and then make all functions in the package part of one struct?
example:
package packageName
import (
"os"
"net/http"
)
type External interface {
urlGet(string) (*http.Response, error)
OpenFile(string, int, os.FileMode) (*os.File, error)
}
func New() ExternalSt {
return ExternalSt{}
}
struct ExternalSt struct {}
func (ExternalSt) urlGet(str string) *http.Response {
return http.get(str)
}
func (ExternalSt) OpenFile (str string, flags int, perms os.FileMode) (*os.File, error) {
return os.OpenFile(str, flags, perms)
}
func (e ExternalSt) Func1 (str string) string {
resp,err := e.urlGet("www.something.com")
// do some other stuff
return resp.string() // or something along these lines
}
func (e ExternalSt) Func2 (str string) string {
sampleFile, sampleFileErr := e.OpenFile(str, os.O_CREATE, 0600)
// do some other stuff
return "done"
}
and then main would be:
package main
import (
...
./packageName
)
func main () {
test := packageName.New()
var1 := "test"
str1 := test.Func1(var1)
var2 := "sample"
str2 := test.Func2(var2)
}
With the above implementation I don't even need the interface, but i'm guessing it would come in handy when Im doing unit tests and need to implement my own mock functions under a test interface to call during testing.
OR
should I create an interface with all the external functions, but pass the new instance I create into the functions as a parameter similar to here. Ex:
package main
import (
...
./packageName
)
func main () {
var test packageName.External
var1 := "test"
str1 := packageName.Func1(test, var1)
var2 := "sample"
str2 := packageName.Func2(test, var2)
}
and the package:
package packageName
import (
"os"
"net/http"
)
type External interface {
urlGet(string) (*http.Response, error)
OpenFile(string, int, os.FileMode) (*os.File, error)
}
func New() ExternalSt {
return ExternalSt{}
}
struct ExternalSt struct {}
func (ExternalSt) urlGet(str string) *http.Response {
return http.get(str)
}
func (ExternalSt) OpenFile (str string, flags int, perms os.FileMode) (*os.File, error) {
return os.OpenFile(str, flags, perms)
}
func Func1 (e External, str string) string {
resp,err := e.urlGet("www.something.com")
// do some other stuff
return resp.string() // or something along these lines
}
func Func2 (e External, str string) string {
sampleFile, sampleFileErr := e.OpenFile(str, os.O_CREATE, 0600)
// do some other stuff
return "done"
}
The second option doesn't seem to work very well as I keep getting an error
panic: runtime error: invalid memory address or nil pointer dereference
[signal SIGSEGV: segmentation violation
but I need more of an understanding of interfaces.
Regardless, I cannot seem to understand which of the 2 options are best to go with.
Or are both these options completely wrong.
NOTE: I'm aware the syntax of the above code is incorrect, and will probably not compile, just looking for an approach here.