Implemented mocking mechanism

This commit implements the choice of back-end, and the back-end
interface. A mock back-end that always errors out is implemented so as
to fit the interface.

Author: EduardGomezEscandell

backend.go

@@ -0,0 +1,14 @@
+//go:build !mock
+
+package gowsl
+
+import (
+	"context"
+
+	"github.com/ubuntu/gowsl/internal/interfaces"
+	"github.com/ubuntu/gowsl/internal/windows"
+)
+
+func selectBackend(ctx context.Context) interfaces.Backend {
+	return windows.Backend{}
+}

backend_mock.go

@@ -0,0 +1,31 @@
+//go:build mock
+
+package gowsl
+
+import (
+	"context"
+
+	"github.com/ubuntu/gowsl/internal/interfaces"
+	"github.com/ubuntu/gowsl/internal/mock"
+	"github.com/ubuntu/gowsl/internal/windows"
+)
+
+type backendQueryType int
+
+const backendQuery backendQueryType = 0
+
+// WithMock adds the mock back-end to the context.
+func WithMock(ctx context.Context) context.Context {
+	return context.WithValue(ctx, backendQuery, mock.Backend{})
+}
+
+func selectBackend(ctx context.Context) interfaces.Backend {
+	v := ctx.Value(backendQuery)
+
+	if v == nil {
+		return windows.Backend{}
+	}
+
+	//nolint: forcetypeassert // The panic is expected and welcome
+	return v.(interfaces.Backend)
+}

distro.go

@@ -7,23 +7,29 @@ package gowsl
 // This file contains utilities to interact with a Distro and its configuration
 
 import (
+	"context"
 	"errors"
 	"fmt"
 	"sort"
 
 	"github.com/google/uuid"
 	"github.com/ubuntu/decorate"
+	"github.com/ubuntu/gowsl/internal/flags"
 )
 
 // Distro is an abstraction around a WSL distro.
 type Distro struct {
+	ctx  context.Context
 	name string
 }
 
 // NewDistro declares a new distribution, but does not register it nor
 // check if it exists.
-func NewDistro(name string) Distro {
-	return Distro{name: name}
+func NewDistro(ctx context.Context, name string) Distro {
+	return Distro{
+		ctx:  ctx,
+		name: name,
+	}
 }
 
 // Name is a getter for the DistroName as shown in "wsl.exe --list".
@@ -35,7 +41,7 @@ func (d Distro) Name() string {
 func (d *Distro) GUID() (id uuid.UUID, err error) {
 	defer decorate.OnError(&err, "could not obtain GUID of %s", d.name)
 
-	distros, err := registeredDistros()
+	distros, err := registeredDistros(d.ctx)
 	if err != nil {
 		return id, err
 	}
@@ -50,38 +56,38 @@ func (d *Distro) GUID() (id uuid.UUID, err error) {
 // Equivalent to:
 //
 //	wsl --terminate <distro>
-func (d Distro) Terminate() error {
-	return terminate(d.Name())
+func (d Distro) Terminate(ctx context.Context) error {
+	return selectBackend(ctx).Terminate(d.Name())
 }
 
 // Shutdown powers off all of WSL, including all other distros.
 // Equivalent to:
 //
 //	wsl --shutdown
-func Shutdown() error {
-	return shutdown()
+func Shutdown(ctx context.Context) error {
+	return selectBackend(ctx).Shutdown()
 }
 
 // SetAsDefault sets a particular distribution as the default one.
 // Equivalent to:
 //
 //	wsl --set-default <distro>
-func (d Distro) SetAsDefault() error {
-	return setAsDefault(d.Name())
+func (d Distro) SetAsDefault(ctx context.Context) error {
+	return selectBackend(ctx).SetAsDefault(d.Name())
 }
 
 // DefaultDistro gets the current default distribution.
-func DefaultDistro() (d Distro, err error) {
+func DefaultDistro(ctx context.Context) (d Distro, err error) {
 	defer decorate.OnError(&err, "could not obtain the default distro")
 
 	// First, we find out the GUID of the default distro
-	r, err := openRegistry(lxssPath)
+	r, err := selectBackend(ctx).OpenLxssRegistry()
 	if err != nil {
 		return d, err
 	}
-	defer r.close()
+	defer r.Close()
 
-	guid, err := r.field("DefaultDistribution")
+	guid, err := r.Field("DefaultDistribution")
 	if err != nil {
 		return d, err
 	}
@@ -92,37 +98,20 @@ func DefaultDistro() (d Distro, err error) {
 	}
 
 	// Last, we find out the name of the distro
-	r, err = openRegistry(lxssPath, guid)
+	r, err = selectBackend(ctx).OpenLxssRegistry(guid)
 	if err != nil {
 		return d, err
 	}
-	defer r.close()
+	defer r.Close()
 
-	name, err := r.field("DistributionName")
+	name, err := r.Field("DistributionName")
 	if err != nil {
 		return d, err
 	}
 
-	return NewDistro(name), err
+	return NewDistro(ctx, name), err
 }
 
-// Windows' WSL_DISTRIBUTION_FLAGS
-// https://learn.microsoft.com/en-us/windows/win32/api/wslapi/ne-wslapi-wsl_distribution_flags
-type wslFlags int
-
-// Allowing underscores in names to keep it as close to Windows as possible.
-const (
-	flag_NONE                  wslFlags = 0x0 //nolint: revive
-	flag_ENABLE_INTEROP        wslFlags = 0x1 //nolint: revive
-	flag_APPEND_NT_PATH        wslFlags = 0x2 //nolint: revive
-	flag_ENABLE_DRIVE_MOUNTING wslFlags = 0x4 //nolint: revive
-
-	// Per the conversation at https://github.com/microsoft/WSL-DistroLauncher/issues/96
-	// the information about version 1 or 2 is on the 4th bit of the flags, which is
-	// currently referenced neither by the API nor the documentation.
-	flag_undocumented_WSL_VERSION wslFlags = 0x8 //nolint: revive
-)
-
 // Configuration is the configuration of the distro.
 type Configuration struct {
 	Version                     uint8             // Type of filesystem used (lxfs vs. wslfs, relevant only to WSL1)
@@ -192,9 +181,9 @@ func (d Distro) GetConfiguration() (c Configuration, err error) {
 	defer decorate.OnError(&err, "could not access configuration for %s", d.name)
 
 	var conf Configuration
-	var flags wslFlags
+	var flags flags.WslFlags
 
-	err = wslGetDistributionConfiguration(
+	err = selectBackend(d.ctx).WslGetDistributionConfiguration(
 		d.Name(),
 		&conf.Version,
 		&conf.DefaultUID,
@@ -280,55 +269,55 @@ func (d *Distro) configure(config Configuration) error {
 		return err
 	}
 
-	return wslConfigureDistribution(d.Name(), config.DefaultUID, flags)
+	return selectBackend(d.ctx).WslConfigureDistribution(d.Name(), config.DefaultUID, flags)
 }
 
 // unpackFlags examines a winWslFlags object and stores its findings in the Configuration.
-func (conf *Configuration) unpackFlags(flags wslFlags) {
+func (conf *Configuration) unpackFlags(f flags.WslFlags) {
 	conf.InteropEnabled = false
-	if flags&flag_ENABLE_INTEROP != 0 {
+	if flags.ENABLE_INTEROP != 0 {
 		conf.InteropEnabled = true
 	}
 
 	conf.PathAppended = false
-	if flags&flag_APPEND_NT_PATH != 0 {
+	if f&flags.APPEND_NT_PATH != 0 {
 		conf.PathAppended = true
 	}
 
 	conf.DriveMountingEnabled = false
-	if flags&flag_ENABLE_DRIVE_MOUNTING != 0 {
+	if f&flags.ENABLE_DRIVE_MOUNTING != 0 {
 		conf.DriveMountingEnabled = true
 	}
 
 	conf.undocumentedWSLVersion = 1
-	if flags&flag_undocumented_WSL_VERSION != 0 {
+	if f&flags.Undocumented_WSL_VERSION != 0 {
 		conf.undocumentedWSLVersion = 2
 	}
 }
 
 // packFlags generates a winWslFlags object from the Configuration.
-func (conf Configuration) packFlags() (wslFlags, error) {
-	flags := flag_NONE
+func (conf Configuration) packFlags() (flags.WslFlags, error) {
+	f := flags.NONE
 
 	if conf.InteropEnabled {
-		flags = flags | flag_ENABLE_INTEROP
+		f = f | flags.ENABLE_INTEROP
 	}
 
 	if conf.PathAppended {
-		flags = flags | flag_APPEND_NT_PATH
+		f = f | flags.APPEND_NT_PATH
 	}
 
 	if conf.DriveMountingEnabled {
-		flags = flags | flag_ENABLE_DRIVE_MOUNTING
+		f = f | flags.ENABLE_DRIVE_MOUNTING
 	}
 
 	switch conf.undocumentedWSLVersion {
 	case 1:
 	case 2:
-		flags = flags | flag_undocumented_WSL_VERSION
+		f = f | flags.Undocumented_WSL_VERSION
 	default:
-		return flags, fmt.Errorf("unknown WSL version %d", conf.undocumentedWSLVersion)
+		return f, fmt.Errorf("unknown WSL version %d", conf.undocumentedWSLVersion)
 	}
 
-	return flags, nil
+	return f, nil
 }

examples/demo.go

@@ -12,7 +12,9 @@ import (
 )
 
 func main() {
-	distro := wsl.NewDistro("Ubuntu-GoWSL-demo")
+	ctx := context.Background()
+
+	distro := wsl.NewDistro(ctx, "Ubuntu-GoWSL-demo")
 
 	// Registering a new distro
 	fmt.Printf("Registering a new distro %q\n", distro.Name())
@@ -37,7 +39,7 @@ func main() {
 	// programs such as bash, python, etc. it'll will start an interactive session
 	// that the user can interact with. This is presumably what wsl.exe uses.
 	// It is a blocking call.
-	if err := distro.Shell(wsl.WithCommand("sh -c 'powershell.exe'")); err != nil {
+	if err := distro.Shell(ctx, wsl.WithCommand("sh -c 'powershell.exe'")); err != nil {
 		fmt.Printf("Interactive session unsuccesful: %v\n", err)
 	} else {
 		fmt.Println("Interactive session succesful")
@@ -89,7 +91,7 @@ func main() {
 	fmt.Println("\nStarting a shell in Ubuntu. Feel free to `exit <NUMBER>` to continue the demo")
 	fmt.Println("")
 
-	if err = distro.Shell(); err != nil {
+	if err = distro.Shell(ctx); err != nil {
 		fmt.Printf("Shell exited with an error: %v\n", err)
 	} else {
 		fmt.Println("Shell exited with no errors")

exec.go

@@ -113,7 +113,7 @@ func (c *Cmd) Start() (err error) {
 		}
 	}
 
-	c.Process, err = WslLaunch(
+	c.Process, err = selectBackend(c.ctx).WslLaunch(
 		c.distro.Name(),
 		c.command,
 		c.UseCWD,
@@ -367,7 +367,7 @@ func (c *Cmd) readerDescriptor(r io.Reader) (f *os.File, err error) {
 	}
 
 	if f, ok := r.(*os.File); ok {
-		isPipe, err := IsPipe(f)
+		isPipe, err := selectBackend(c.ctx).IsPipe(f)
 		if err == nil && isPipe {
 			// It's a pipe: no need to create our own pipe.
 			return f, nil
@@ -410,7 +410,7 @@ func (c *Cmd) writerDescriptor(w io.Writer) (f *os.File, err error) {
 	}
 
 	if f, ok := w.(*os.File); ok {
-		isPipe, err := IsPipe(f)
+		isPipe, err := selectBackend(c.ctx).IsPipe(f)
 		if err == nil && isPipe {
 			// It's a pipe: no need to create our own pipe.
 			return f, nil

go.sum

@@ -25,6 +25,7 @@ github.com/ubuntu/decorate v0.0.0-20230125165522-2d5b0a9bb117/go.mod h1:mx0Tjbqs
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20220715151400-c0bba94af5f8/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU=
 golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=

internal/flags/flags.go

@@ -0,0 +1,24 @@
+// Package flags contains the enum used by WSL to display
+// some configuration of a WSL distro.
+//
+// TODO: This can probably be moved to the back-end.
+package flags
+
+// WslFlags is an alias for Windows' WSL_DISTRIBUTION_FLAGS
+// https://learn.microsoft.com/en-us/windows/win32/api/wslapi/ne-wslapi-wsl_distribution_flags
+type WslFlags int32
+
+// Allowing underscores in names to keep it as close to Windows as possible.
+const (
+	// All nolints are regarding the use of UPPPER_CASE.
+
+	NONE                  WslFlags = 0x0
+	ENABLE_INTEROP        WslFlags = 0x1 //nolint: revive
+	APPEND_NT_PATH        WslFlags = 0x2 //nolint: revive
+	ENABLE_DRIVE_MOUNTING WslFlags = 0x4 //nolint: revive
+
+	// Per the conversation at https://github.com/microsoft/WSL-DistroLauncher/issues/96
+	// the information about version 1 or 2 is on the 4th bit of the flags, which is
+	// currently referenced neither by the API nor the documentation.
+	Undocumented_WSL_VERSION WslFlags = 0x8 //nolint: revive
+)

internal/interfaces/interfaces.go

@@ -0,0 +1,37 @@
+// Package interfaces defines all the actions that a back-end to GoWSL must
+// be able to perform in order to run, or otherwise mock WSL.
+package interfaces
+
+import (
+	"os"
+
+	"github.com/ubuntu/gowsl/internal/flags"
+)
+
+// Backend defines what a back-end to GoWSL must be able to do or mock.
+type Backend interface {
+	// Registry
+	OpenLxssRegistry(path ...string) (RegistryKey, error)
+
+	// wsl.exe
+	Shutdown() error
+	Terminate(distroName string) error
+	SetAsDefault(distroName string) error
+
+	// Win32
+	IsPipe(f *os.File) (bool, error)
+	WslConfigureDistribution(distributionName string, defaultUID uint32, wslDistributionFlags flags.WslFlags) error
+	WslGetDistributionConfiguration(distroName string, distributionVersion *uint8, defaultUID *uint32, wslDistributionFlags *flags.WslFlags, defaultEnvironmentVariables *map[string]string) error
+	WslLaunch(distroName string, command string, useCWD bool, stdin *os.File, stdout *os.File, stderr *os.File) (*os.Process, error)
+	WslLaunchInteractive(distributionName string, command string, useCurrentWorkingDirectory bool) (uint32, error)
+	WslRegisterDistribution(distributionName string, tarGzFilename string) error
+	WslUnregisterDistribution(distributionName string) error
+}
+
+// RegistryKey mocks a very small subset of behaviours of a Windows Registry key, enough
+// for GoWSL to do the limited amount of traversal and reading that it needs.
+type RegistryKey interface {
+	Close() error
+	Field(name string) (string, error)
+	SubkeyNames() ([]string, error)
+}

internal/mock/backend.go

@@ -0,0 +1,8 @@
+//go:build mock
+
+// Package mock mocks the WSL api, useful for tests as it allows parallelism,
+// decoupling, and execution speed.
+package mock
+
+// Backend implements the Backend interface.
+type Backend struct{}