github.com/vchain-us/vcn@v0.9.11-0.20210921212052-a2484d23c0b3/integration/feature_flag_test.go

package main

import (
	"fmt"
	"io/ioutil"
	"log"
	"os"
	"os/exec"
	"path"
	"reflect"
	"regexp"
	"runtime"
	"testing"
)

var (
	testApiKey1 string = os.Getenv("CNIL_GITHUB_TEST_API_KEY1")
	testApiKey2 string = os.Getenv("CNIL_GITHUB_TEST_API_KEY2")
	revokedKey  string = os.Getenv("CNIL_GITHUB_REVOKED_KEY")
	testHost    string = os.Getenv("CNIL_GITHUB_TEST_HOST")
	testPort    string = os.Getenv("CNIL_GITHUB_TEST_PORT")
	signerID1   string = os.Getenv("CNIL_SIGNERID1")
	// signerID2       string = os.Getenv("CNIL_SIGNERID2")
	revokedSigner string = os.Getenv("REVOKED_SIGNERID")
	revokedHash   string = os.Getenv("REVOKED_HASH")
	untrustedHash string = os.Getenv("UNTRUSTED_HASH")
	//TODO: Create a list of images and make this part of the test configuration rather than a secret
	imageToNotarize string = os.Getenv("IMAGE_TO_NOTARIZE")

	attributeRE             *regexp.Regexp = regexp.MustCompile(".*test_attr_value1.*")
	loginSuccessRe          *regexp.Regexp = regexp.MustCompile("Login successful")
	statusTrustedRE         *regexp.Regexp = regexp.MustCompile("Status:.*TRUSTED")
	statusUntrustedRE       *regexp.Regexp = regexp.MustCompile("Status:.*UNTRUSTED")
	statusRevokedRE         *regexp.Regexp = regexp.MustCompile("Status:.*REVOKED")
	notarizationsFoundRE    *regexp.Regexp = regexp.MustCompile("notarizations found")
	noSignerIdRE            *regexp.Regexp = regexp.MustCompile("no signer ID provided")
	apiKeyRevokedRE         *regexp.Regexp = regexp.MustCompile("Apikey revoked")
	recursiveNotarizationRE *regexp.Regexp = regexp.MustCompile(`notarized.*\d+.*items`)
	badApikeyRE             *regexp.Regexp = regexp.MustCompile("api key not valid")
	logoutSuccessfulRE      *regexp.Regexp = regexp.MustCompile("Logout successful")
	logoutNotLoggedInRE     *regexp.Regexp = regexp.MustCompile("No logged-in user")
	needToLoginRE           *regexp.Regexp = regexp.MustCompile("You need to be logged in")
	cmd_str                 string         = getCmdFqp()
)

func findBinaryName() string {
	os := runtime.GOOS
	binaryName := "vcn"
	switch os {
	case "windows":
		return binaryName + ".exe"
	default:
		return binaryName
	}
}

func getCmdFqp() string {
	binary := findBinaryName()
	current_dir, err := os.Getwd()
	if err != nil {
		log.Printf("Error getting current directory, aborting tests")
		os.Exit(1)
	}
	working_dir := path.Dir(current_dir)
	return path.Join(working_dir, binary)
}

/** Tests unauthenticated interaction with blockchain backend, currently limited until  google/goexpect is added to this test suite since interactive login is required **/
func TestBlockchainContext(t *testing.T) {
	tests := []struct {
		name     string
		args     []string
		x_output *regexp.Regexp
	}{
		{"Authenticate hash - Not logged in", []string{"a", "--hash", "75238fba430613c4339f06f1951b375afed0d051e9869a65d639c64b54671532"}, statusTrustedRE},
	}
	os.Setenv("VCN_SKIP_SIGNATURE_VERIFY", "true")
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			cmd := exec.Command(cmd_str, tt.args...)
			output, err := cmd.CombinedOutput()
			if err != nil {
				t.Fatal(err)
			}
			actual := string(output)

			if !tt.x_output.MatchString(actual) {
				x_string := fmt.Sprintf("Expected %s but got %s", tt.x_output, actual)
				log.Fatal(x_string)
			}
		})
	}
}

type C struct{}

func (c C) Fixture_set_env_api_key() {
	_, f := os.LookupEnv("VCN_LC_API_KEY")
	if f {
		os.Setenv("VCN_LC_API_KEY", testApiKey2)
	} else {
		os.Setenv("VCN_LC_API_KEY", testApiKey1)
	}
	log.Printf("API Key set to %s", os.Getenv("VCN_LC_API_KEY"))

}

func (c C) FixturePullImage() {
	cmd := exec.Command("docker", "pull", imageToNotarize)
	out, err := cmd.CombinedOutput()
	cmd.Run()
	if err != nil {
		log.Printf("Error pulling image %s", imageToNotarize)
	}
	log.Println(string(out))
}

type VcnTest struct {
	// Name of the test
	name string
	// CLI Args
	args []string
	// Array of regular expressions to vaidate stdout/stderr
	x_output []*regexp.Regexp
	// Fixture (create func(c C) Function_name, uses reflection)
	fixture string
}

func executeTests(testArray []VcnTest, t *testing.T) {
	for _, tt := range testArray {
		t.Run(tt.name, func(t *testing.T) {
			if tt.fixture != "" {
				c := C{}
				f := reflect.ValueOf(c).MethodByName(tt.fixture)
				f.Call(nil)
			}
			cmd := exec.Command(cmd_str, tt.args...)
			out, err := cmd.CombinedOutput()
			cmd.Run()
			if err != nil {
				log.Println("Logging stdErr, tests may still pass")
				log.Println(fmt.Sprint(err) + ": " + string(out))
			}
			actual := string(out)
			for _, regex := range tt.x_output {
				if !regex.MatchString(actual) {
					t.Log(fmt.Sprintf("Test %s failed", tt.name))
					x_string := fmt.Sprintf("Expected %s but got %s", tt.x_output, actual)
					log.Fatal(x_string)
				}
			}

		})
	}

}

/** Tests authenticated interaction with CNIL backend**/
func TestCNcloudContext(t *testing.T) {
	var tests = []VcnTest{
		{"Login to private test instance", []string{"login", "--lc-host", testHost, "--lc-port", testPort, "--lc-api-key", testApiKey1}, []*regexp.Regexp{loginSuccessRe}, "Fixture_set_env_api_key"},
		{"Notarize a simple file", []string{"n", "feature_flag_test.go"}, []*regexp.Regexp{statusTrustedRE}, ""},
		{"Authenticate a previously notarized file", []string{"a", "feature_flag_test.go"}, []*regexp.Regexp{statusTrustedRE}, ""},
		{"Untrust a previously notarized file", []string{"untrust", "feature_flag_test.go"}, []*regexp.Regexp{statusUntrustedRE}, ""},
		{"Authenticate a previously untrusted file", []string{"a", "feature_flag_test.go"}, []*regexp.Regexp{statusUntrustedRE}, ""},
		{"Inspect a previously untrusted file using a date range", []string{"i", "feature_flag_test.go", "--start", "2021/08/25-00:00:00", "--end", "2021/08/25-23:59:00", "--first", "10"}, []*regexp.Regexp{notarizationsFoundRE}, ""},
		{"Inspect a previously untrusted file (No Args)", []string{"inspect", "feature_flag_test.go"}, []*regexp.Regexp{noSignerIdRE}, ""},
		{"Inspect a previously untrusted file --first flag", []string{"inspect", "feature_flag_test.go", "--first", "1"}, []*regexp.Regexp{notarizationsFoundRE}, ""},
		{"Inspect a previously untrusted file --last flag", []string{"inspect", "feature_flag_test.go", "--last", "1"}, []*regexp.Regexp{notarizationsFoundRE}, ""},
		{"Inspect a previously untrusted file hash flag", []string{"inspect", "--hash", untrustedHash, "--signerID", signerID1}, []*regexp.Regexp{notarizationsFoundRE}, ""},
		{"Notarize a file with specific attributes", []string{"n", "--attr", "test_attr1=test_attr_value1", "feature_flag_test.go"}, []*regexp.Regexp{attributeRE}, ""},
		{"Authenticate with previous signerId", []string{"a", "feature_flag_test.go", "--signerID", signerID1}, []*regexp.Regexp{statusTrustedRE}, "Fixture_set_env_api_key"},
		{"Authenticate with a revoked signerId", []string{"a", "--hash", revokedHash, "--signerID", revokedSigner}, []*regexp.Regexp{apiKeyRevokedRE, statusRevokedRE}, ""},
		{"Notarize recursively", []string{"n", "-r", "*.go"}, []*regexp.Regexp{recursiveNotarizationRE}, ""},
		{"Notarize docker image", []string{"n", fmt.Sprintf("docker://%s", imageToNotarize)}, []*regexp.Regexp{statusTrustedRE}, "FixturePullImage"},
		{"Notarize git repo ", []string{"n", "git://../"}, []*regexp.Regexp{statusTrustedRE}, ""},
		{"Notarize git repo BOM", []string{"n", "--bom", "git://../"}, []*regexp.Regexp{statusTrustedRE}, ""},
		{"Attempt to notarize using revoked API Key", []string{"n", "git://../", "--lc-api-key", revokedKey}, []*regexp.Regexp{badApikeyRE}, ""},
		{"Attempt to notarize using an invalid API Key", []string{"n", "git://../", "--lc-api-key", "lc._"}, []*regexp.Regexp{badApikeyRE}, ""},
		{"Logout", []string{"logout"}, []*regexp.Regexp{logoutSuccessfulRE}, ""},
		{"Logout without logging in", []string{"logout"}, []*regexp.Regexp{logoutNotLoggedInRE}, ""},
		{"Attempt to notarize after logging out", []string{"n", "git://../", "--lc-api-key", "lc._"}, []*regexp.Regexp{needToLoginRE}, ""},
	}
	os.Setenv("VCN_SKIP_SIGNATURE_VERIFY", "true")
	executeTests(tests, t)
}

func TestBomUnsupported(t *testing.T) {
	// Negative tests still can't use the above illustrated method
	pckManErrorRE := *regexp.MustCompile(`.*cannot identify package manager.*`)
	c := C{}
	c.FixturePullImage()
	cmd := exec.Command(cmd_str, "bom", fmt.Sprintf("docker://%s", imageToNotarize))
	out, err := cmd.CombinedOutput()
	cmd.Run()
	log.Println(err)
	if err != nil {
		// We want to be here
		if !pckManErrorRE.MatchString(string(out)) {
			t.Fatal("Package manager error not found")
		}
	} else {
		t.Fatal("Unsupported docker image generated no errors")
	}
}

func TestBomSupportedDockerImage(t *testing.T) {
	exec.Command("docker", "pull", "codenotary/vcn:bom-nodejs").Run()
	var tests = []VcnTest{
		{"Run vcn bom on a supported docker image", []string{"bom", "docker://codenotary/vcn:bom-nodejs"}, []*regexp.Regexp{regexp.MustCompile(`.*ca-certificates.*`), regexp.MustCompile(`.*openssl.*`)}, ""},
	}
	executeTests(tests, t)

}

func TestBomSpdxFile(t *testing.T) {
	var vcnBomFiles = []string{"vcn-bom.spdx", "git-bom.spdx", "docker-bom.spdx"}
	var tests = []VcnTest{
		{"Run vcn bom --spdx-file some_file on VCN Binary", []string{"bom", cmd_str, "--bom-spdx", vcnBomFiles[0]}, []*regexp.Regexp{regexp.MustCompile(`.*github.com/prometheus/common*`), regexp.MustCompile(`.*github.com/package-url/packageurl-go*`), regexp.MustCompile(`.*github.com/matttproud/golang_protobuf_extensions*`)}, ""},
		{"Run vcn bom --spdx-file this-repository", []string{"bom", "git://../", "--bom-spdx", vcnBomFiles[1]}, []*regexp.Regexp{regexp.MustCompile(`.*github.com/prometheus/common*`), regexp.MustCompile(`.*github.com/package-url/packageurl-go*`), regexp.MustCompile(`.*github.com/matttproud/golang_protobuf_extensions*`)}, ""},
	}
	executeTests(tests, t)
	spdxContent, err := ioutil.ReadFile(vcnBomFiles[0])
	spdxString := string(spdxContent)
	if err != nil {
		t.Fatal("failed to read spdx file contents")
	}
	for _, regex := range tests[0].x_output {
		if !regex.MatchString(spdxString) {
			t.Fatal(fmt.Sprintf("Dependency %s missing from bom-spdx output for vcn", regex))
		}
	}
}

func TestBomWhatIncludes(t *testing.T) {
	vcnDependency := "gocom://github.com/spf13/viper@v1.8.1"
	var tests = []VcnTest{
		// Login required for this
		{"Login to private test instance", []string{"login", "--lc-host", testHost, "--lc-port", testPort, "--lc-api-key", testApiKey1}, []*regexp.Regexp{loginSuccessRe}, ""},
		{"Run vcn a git://../ --bom-what-includes some_dependency", []string{"a", "--bom-what-includes", vcnDependency}, []*regexp.Regexp{regexp.MustCompile(`.*git@github.com:codenotary/vcn.git*`)}, ""},
	}
	executeTests(tests, t)
}