feat(compute): add support for cpp for compute

Author: anthony-gomez-fastly

fastly-dev

@@ -696,6 +696,12 @@ func identifyToolchain(c *BuildCommand) (string, error) {
 func language(toolchain, manifestFilename string, c *BuildCommand, in io.Reader, out io.Writer, spinner text.Spinner) (*Language, error) {
 	var language *Language
 	switch toolchain {
+	case "cpp":
+		language = NewLanguage(&LanguageOptions{
+			Name:            "cpp",
+			SourceDirectory: CPPSourceDirectory,
+			Toolchain:       NewCPP(c, in, manifestFilename, out, spinner),
+		})
 	case "go":
 		language = NewLanguage(&LanguageOptions{
 			Name:            "go",

pkg/commands/compute/build.go

@@ -662,6 +662,209 @@ func TestBuildJavaScript(t *testing.T) {
 	}
 }
 
+func TestBuildCPP(t *testing.T) {
+	if os.Getenv("TEST_COMPUTE_BUILD_CPP") == "" && os.Getenv("TEST_COMPUTE_BUILD") == "" {
+		t.Log("skipping test")
+		t.Skip("Set TEST_COMPUTE_BUILD to run this test")
+	}
+
+	args := testutil.SplitArgs
+
+	scenarios := []struct {
+		name                 string
+		args                 []string
+		applicationConfig    *config.File
+		fastlyManifest       string
+		wantError            string
+		wantRemediationError string
+		wantOutput           []string
+	}{
+		{
+			name:                 "no fastly.toml manifest",
+			args:                 args("compute build"),
+			wantError:            "error reading fastly.toml: file not found",
+			wantRemediationError: "Run `fastly compute init` to ensure a correctly configured manifest.",
+		},
+		{
+			name: "empty language",
+			args: args("compute build"),
+			fastlyManifest: `
+			manifest_version = 2
+			name = "test"`,
+			wantError: "language cannot be empty, please provide a language",
+		},
+		{
+			name: "unknown language",
+			args: args("compute build"),
+			fastlyManifest: `
+			manifest_version = 2
+			name = "test"
+			language = "foobar"`,
+			wantError: "unsupported language foobar",
+		},
+		// The following test validates that the project compiles successfully even
+		// though the fastly.toml manifest has no build script. There should be a
+		// default build script inserted.
+		//
+		// NOTE: This test passes --verbose so we can validate specific outputs.
+		{
+			name: "build script inserted dynamically when missing",
+			args: args("compute build --verbose"),
+			applicationConfig: &config.File{
+				Language: config.Language{
+					CPP: config.CPP{
+						ToolchainConstraint: ">= 14.0.0",
+						WasmWasiTarget:      "wasm32-wasip1",
+					},
+				},
+			},
+			fastlyManifest: `
+			manifest_version = 2
+			name = "test"
+			language = "cpp"`,
+			wantOutput: []string{
+				"No [scripts.build] found in fastly.toml.", // requires --verbose
+				"The following default build command for C++ will be used",
+				"clang++ -O3 --target=wasm32-wasip1 -o ./bin/main.wasm main.cpp",
+			},
+		},
+		{
+			name: "build error",
+			args: args("compute build"),
+			applicationConfig: &config.File{
+				Language: config.Language{
+					CPP: config.CPP{
+						ToolchainConstraint: ">= 14.0.0",
+						WasmWasiTarget:      "wasm32-wasip1",
+					},
+				},
+			},
+			fastlyManifest: `
+			manifest_version = 2
+			name = "test"
+			language = "cpp"
+
+			[scripts]
+			build = "echo no compilation happening"`,
+			wantRemediationError: compute.DefaultBuildErrorRemediation,
+		},
+		// NOTE: This test passes --verbose so we can validate specific outputs.
+		{
+			name: "successful build",
+			args: args("compute build --verbose"),
+			applicationConfig: &config.File{
+				Language: config.Language{
+					CPP: config.CPP{
+						ToolchainConstraint: ">= 14.0.0",
+						WasmWasiTarget:      "wasm32-wasip1",
+					},
+				},
+			},
+			fastlyManifest: `
+			manifest_version = 2
+			name = "test"
+			language = "cpp"
+
+			[scripts]
+			build = "clang++ -O3 --target=wasm32-wasip1 -o bin/main.wasm main.cpp"`,
+			wantOutput: []string{
+				"Creating ./bin directory (for Wasm binary)",
+				"Built package",
+			},
+		},
+	}
+	for testcaseIdx := range scenarios {
+		testcase := &scenarios[testcaseIdx]
+		t.Run(testcase.name, func(t *testing.T) {
+			// We're going to chdir to a build environment,
+			// so save the PWD to return to, afterwards.
+			pwd, err := os.Getwd()
+			if err != nil {
+				t.Fatal(err)
+			}
+
+			wasmtoolsBinName := "wasm-tools"
+
+			// Windows was having issues when trying to move a tmpBin file (which
+			// represents the latest binary downloaded from GitHub) to binPath (which
+			// represents the existing binary installed on a user's machine).
+			//
+			// The problem was, for the sake of the tests, I just create one file
+			// `wasmtoolsBinName` and used that for both `tmpBin` and `binPath` and
+			// this works fine on *nix systems. But once Windows did `os.Rename()` and
+			// move tmpBin to binPath it would no longer be able to set permissions on
+			// the binPath because it didn't think the file existed any more. My guess
+			// is that moving a file over itself causes Windows to remove the file.
+			//
+			// So to work around that issue I just create two separate files because
+			// in reality that's what the CLI will be dealing with. I only used one
+			// file for the sake of test case convenience (which ironically became
+			// very INCONVENIENT when the tests started unexpectedly failing on
+			// Windows and caused me a long time debugging).
+			latestDownloaded := wasmtoolsBinName + "-latest-downloaded"
+
+			// Create test environment
+			rootdir := testutil.NewEnv(testutil.EnvOpts{
+				T: t,
+				Copy: []testutil.FileIO{
+					{Src: filepath.Join("testdata", "build", "cpp", "main.cpp"), Dst: "main.cpp"},
+				},
+				Write: []testutil.FileIO{
+					{Src: `#!/usr/bin/env bash
+            echo wasm-tools 1.0.4`, Dst: wasmtoolsBinName, Executable: true},
+					{Src: `#!/usr/bin/env bash
+            echo wasm-tools 2.0.0`, Dst: latestDownloaded, Executable: true},
+					{Src: testcase.fastlyManifest, Dst: manifest.Filename},
+				},
+			})
+			defer os.RemoveAll(rootdir)
+			wasmtoolsBinPath := filepath.Join(rootdir, wasmtoolsBinName)
+
+			// Before running the test, chdir into the build environment.
+			// When we're done, chdir back to our original location.
+			// This is so we can reliably copy the testdata/ fixtures.
+			if err := os.Chdir(rootdir); err != nil {
+				t.Fatal(err)
+			}
+			defer func() {
+				_ = os.Chdir(pwd)
+			}()
+
+			var stdout threadsafe.Buffer
+			app.Init = func(_ []string, _ io.Reader) (*global.Data, error) {
+				opts := testutil.MockGlobalData(testcase.args, &stdout)
+				if testcase.applicationConfig != nil {
+					opts.Config = *testcase.applicationConfig
+				}
+				opts.Versioners = global.Versioners{
+					WasmTools: mock.AssetVersioner{
+						AssetVersion:    "1.2.3",
+						BinaryFilename:  wasmtoolsBinName,
+						DownloadOK:      true,
+						DownloadedFile:  latestDownloaded,
+						InstallFilePath: wasmtoolsBinPath, // avoid overwriting developer's actual wasm-tools install
+					},
+				}
+				return opts, nil
+			}
+			err = app.Run(testcase.args, nil)
+
+			t.Log(stdout.String())
+
+			testutil.AssertRemediationErrorContains(t, err, testcase.wantRemediationError)
+
+			// NOTE: Some errors we want to assert only the remediation.
+			// e.g. a 'stat' error isn't the same across operating systems/platforms.
+			if testcase.wantError != "" {
+				testutil.AssertErrorContains(t, err, testcase.wantError)
+			}
+			for _, s := range testcase.wantOutput {
+				testutil.AssertStringContains(t, stdout.String(), s)
+			}
+		})
+	}
+}
+
 // NOTE: TestBuildOther also validates the post_build settings.
 func TestBuildOther(t *testing.T) {
 	args := testutil.SplitArgs

pkg/commands/compute/build_test.go

@@ -57,7 +57,7 @@ type InitCommand struct {
 }
 
 // Languages is a list of supported language options.
-var Languages = []string{"rust", "javascript", "go", "other"}
+var Languages = []string{"rust", "javascript", "go", "cpp", "other"}
 
 // NewInitCommand returns a usable command registered under the parent.
 func NewInitCommand(parent argparser.Registerer, g *global.Data) *InitCommand {

pkg/commands/compute/init.go

@@ -37,6 +37,11 @@ func NewLanguages(kits config.StarterKitLanguages) []*Language {
 			DisplayName: "Go",
 			StarterKits: kits.Go,
 		}),
+		NewLanguage(&LanguageOptions{
+			Name:        "cpp",
+			DisplayName: "C++",
+			StarterKits: kits.CPP,
+		}),
 		NewLanguage(&LanguageOptions{
 			Name:        "other",
 			DisplayName: "Other ('bring your own' Wasm binary)",