Adding detectors (#46)

* rename secret

* Add supporting docs and tooling for adding new detectors

.gitattributes

@@ -0,0 +1,2 @@
+*.go text eol=lf
+*.md text eol=lf

Makefile

@@ -43,3 +43,6 @@ run-debug:
 
 protos:
 	docker run -u "$(shell id -u)" -v "$(shell dirname $(realpath $(firstword $(MAKEFILE_LIST))))":/pwd "${PROTOS_IMAGE}" bash -c "cd /pwd; /pwd/scripts/gen_proto.sh"
+
+protos-windows:
+	docker run -v "$(shell cygpath -w $(shell pwd))":/pwd "${PROTOS_IMAGE}" bash -c "cd /pwd; ./scripts/gen_proto.sh"

hack/docs/Adding_Detectors.md

@@ -0,0 +1,125 @@
+# Secret Detectors
+
+Secret Detectors have these two major functions:
+
+1. Given some bytes, extract possible secrets, typically using a regex.
+2. Validate the secrets against the target API, typically using a HTTP client.
+
+The purpose of Secret Detectors is to discover secrets with exceptionally high signal. High rates of false positives are not accepted.
+
+## Table of Contents
+
+- [Secret Detectors](#secret-detectors)
+  - [Table of Contents](#table-of-contents)
+  - [Getting Started](#getting-started)
+    - [Sourcing Guidelines](#sourcing-guidelines)
+    - [Development Guidelines](#development-guidelines)
+    - [Development Dependencies](#development-dependencies)
+    - [Creating a new Secret Scanner](#creating-a-new-secret-detector)
+  - [Addendum](#addendum)
+    - [Managing Test Secrets](#managing-test-secrets)
+    - [Setting up Google Cloud SDK](#setting-up-google-cloud-sdk)
+
+## Getting Started
+
+### Sourcing Guidelines
+
+We are interested in detectors for services that meet at least one of these criteria
+- host data (they store any sort of data provided)
+- have paid services (having a free or trial tier is okay though)
+
+If you think that something should be included outside of these guidelines, please let us know.
+
+### Development Guidelines
+
+- When reasonable, favor using the `net/http` library to make requests instead of bringing in another library.
+- Use the [`common.SaneHttpClient`](pkg/common/http.go) for the `http.Client` whenever possible.
+- We recommend an editor with gopls integration (such as Vscode with Go plugin) for benefits like easily running tests, autocompletion, linting, type checking, etc.
+
+### Development Dependencies
+
+- A GitLab account
+- A Google account
+- [Google Cloud SDK installed](#setting-up-google-cloud-sdk)
+- Go 1.16
+- Make
+
+### Creating a new Secret Scanner
+
+1. Identify the Secret Scanner name from the [proto/secrets.proto](proto/secrets.proto) `DetectorType` enum.
+
+2. Generate the SecretScanner
+
+   ```bash
+   go run hack/generate/generate.go detector <DetectorType enum name>
+   ```
+
+3. Complete the secret detector.
+
+   The previous step templated a boilerplate + some example code as a package in the `pkg/secrets` folder for you to work on.
+   The secret detector can be completed with these general steps:
+
+   1. Add the test secret to GCP Secrets. See [managing test secrets](#managing-test-secrets)
+   2. Update the pattern regex and keywords. Try iterating with [regex101.com](http://regex101.com/).
+   3. Update the verifier code to use a non-destructive API call that can determine whether the secret is valid or not.
+   4. Update the tests with these test cases at minimum:
+      1. Found and verified (using a credential loaded from GCP Secrets)
+      2. Found and unverified
+      3. Not found
+      4. Any false positive cases that you come across
+   5. Create a merge request for review. CI tests must be passing.
+
+## Addendum
+
+### Managing Test Secrets
+
+Do not embed test credentials in the test code. Instead, use GCP Secrets Manager.
+
+1. Access the latest secret version for modification.
+
+   Note: `/tmp/s` is a valid path on Linux. You will need to change that for Windows or OSX, otherwise you will see an error. On Windows you will also need to install [WSL](https://docs.microsoft.com/en-us/windows/wsl/install).
+
+   ```bash
+   gcloud secrets versions access --project thog-contractor-tests --secret detectors3 latest > /tmp/s
+   ```
+
+2. Add the secret that you need for testing.
+
+   The command above saved it to `/tmp/s`.
+
+   The format is standard env file format,
+
+   ```bash
+   SECRET_TYPE_ONE=value
+   SECRET_TYPE_ONE_INACTIVE=v@lue
+   ```
+
+3. Update the secret version with your modification.
+
+   ```bash
+   gcloud secrets versions add --project thog-contractor-tests detectors3 --data-file /tmp/s
+   ```
+
+4. Access the secret value as shown in the [example code](pkg/secrets/heroku/heroku_test.go).
+
+### Setting up Google Cloud SDK
+
+1. Install the Google Cloud SDK: https://cloud.google.com/sdk/docs/install
+2. Authenticate with `gcloud auth login --update-adc` using your Google account
+
+### Adding Protos in Windows
+
+1. Install Ubuntu App in Microsoft Store https://www.microsoft.com/en-us/p/ubuntu/9nblggh4msv6.
+2. Install Docker Desktop https://www.docker.com/products/docker-desktop. Enable WSL integration to Ubuntu. In Docker app, go to Settings->Resources->WSL INTEGRATION->enable Ubuntu.
+3. Open Ubuntu cli and install `dos2unix`.
+   ```bash
+   sudo apt install dos2unix
+   ```
+4. Identify the `trufflehog` local directory and convert `scripts/gen_proto.sh` file in Unix format.
+   ```bash
+   dos2unix ./scripts/gen_proto.sh
+   ```
+5. Open [proto/secrets.proto](proto/secrets.proto) file and add new detectors then save it. Make sure Docker is running and run this in Ubuntu command line.
+   ```bash
+   make protos
+   ```

hack/generate/generate.go

@@ -0,0 +1,126 @@
+package main
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+	"text/template"
+
+	"github.com/go-errors/errors"
+	"gopkg.in/alecthomas/kingpin.v2"
+)
+
+var (
+	app                             = kingpin.New("generate", "Generate is used to write new features.")
+	kind                            = app.Arg("kind", "Kind of thing to generate.").Required().Enum("detector")
+	name                            = app.Arg("name", "Name of the Source/Detector to generate.").Required().String()
+	nameTitle, nameLower, nameUpper string
+)
+
+func main() {
+	log.SetFlags(log.Lmsgprefix)
+	log.SetPrefix("😲 [generate] ")
+
+	kingpin.MustParse(app.Parse(os.Args[1:]))
+	nameTitle = strings.Title(*name)
+	nameLower = strings.ToLower(*name)
+	nameUpper = strings.ToUpper(*name)
+
+	switch *kind {
+	case "detector":
+		mustWriteTemplates([]templateJob{
+			{
+				TemplatePath:  "pkg/detectors/heroku/heroku.go",
+				WritePath:     filepath.Join(folderPath(), nameLower+".go"),
+				ReplaceString: []string{"heroku"},
+			},
+			{
+				TemplatePath:  "pkg/detectors/heroku/heroku_test.go",
+				WritePath:     filepath.Join(folderPath(), nameLower+"_test.go"),
+				ReplaceString: []string{"heroku"},
+			},
+		})
+		// case "source":
+		// 	mustWriteTemplates([]templateJob{
+		// 		{
+		// 			TemplatePath:  "pkg/sources/filesystem/filesystem.go",
+		// 			WritePath:     filepath.Join(folderPath(), nameLower+".go"),
+		// 			ReplaceString: []string{"filesystem"},
+		// 		},
+		// 		{
+		// 			TemplatePath:  "pkg/sources/filesystem/filesystem_test.go",
+		// 			WritePath:     filepath.Join(folderPath(), nameLower+"_test.go"),
+		// 			ReplaceString: []string{"filesystem"},
+		// 		},
+		// 	})
+	}
+}
+
+type templateJob struct {
+	TemplatePath  string
+	WritePath     string
+	ReplaceString []string
+}
+
+func mustWriteTemplates(jobs []templateJob) {
+	log.Printf("Generating %s %s\n", strings.Title(*kind), nameTitle)
+
+	// Make the folder.
+	log.Printf("Creating folder %s\n", folderPath())
+	err := makeFolder(folderPath())
+	if err != nil {
+		log.Fatal(err)
+	}
+
+	// Write the files from templates.
+	for _, job := range jobs {
+		tmplBytes, err := ioutil.ReadFile(job.TemplatePath)
+		if err != nil {
+			log.Fatal(err)
+		}
+		tmplRaw := string(tmplBytes)
+
+		for _, rplString := range job.ReplaceString {
+			tmplRaw = strings.ReplaceAll(tmplRaw, strings.ToLower(rplString), "<<.NameLower>>")
+			tmplRaw = strings.ReplaceAll(tmplRaw, strings.Title(rplString), "<<.NameTitle>>")
+			tmplRaw = strings.ReplaceAll(tmplRaw, strings.ToUpper(rplString), "<<.NameUpper>>")
+		}
+
+		tmpl := template.Must(template.New("main").Delims("<<", ">>").Parse(tmplRaw))
+
+		log.Printf("Writing file %s\n", job.WritePath)
+		f, err := os.OpenFile(job.WritePath, os.O_RDWR|os.O_CREATE|os.O_TRUNC, 0644)
+		if err != nil {
+			log.Fatal(err)
+		}
+		tmpl.Execute(f, templateData{
+			NameTitle: nameTitle,
+			NameLower: nameLower,
+			NameUpper: nameUpper,
+		})
+	}
+}
+
+type templateData struct {
+	NameTitle string
+	NameLower string
+	NameUpper string
+}
+
+func folderPath() string {
+	return filepath.Join("pkg/", *kind+"s", nameLower)
+}
+
+func makeFolder(path string) error {
+	_, err := os.Stat(path)
+	if os.IsNotExist(err) {
+		err := os.MkdirAll(path, 0755)
+		if err != nil {
+			return errors.New(err)
+		}
+		return nil
+	}
+	return errors.Errorf("%s %s already exists", *kind, *name)
+}

hack/generate/test.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+set -eu
+
+function cleanup {
+  rm -rf pkg/detectors/test
+}
+trap cleanup EXIT
+
+export CGO_ENABLED=0
+
+export FORCE_PASS_DIFF=true
+
+echo "████████████ Testing generate Detector"
+go run hack/generate/generate.go detector Test
+go test ./pkg/detectors/test -benchmem -bench .
+echo ""

pkg/detectors/abbysale/abbysale_test.go

@@ -16,7 +16,7 @@ import (
 func TestAbbysale_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/abstract/abstract_test.go

@@ -16,7 +16,7 @@ import (
 func TestAbstract_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/abuseipdb/abuseipdb_test.go

@@ -16,7 +16,7 @@ import (
 func TestAbuseIPDB_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/accuweather/accuweather_test.go

@@ -16,7 +16,7 @@ import (
 func TestAccuweather_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/adafruitio/adafruitio_test.go

@@ -16,7 +16,7 @@ import (
 func TestAdafruitIO_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/adobeio/adobeio_test.go

@@ -16,7 +16,7 @@ import (
 func TestAdobeIO_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/adzuna/adzuna_test.go

@@ -16,7 +16,7 @@ import (
 func TestAdzuna_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/agora/agora_test.go

@@ -16,7 +16,7 @@ import (
 func TestAgora_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/airbrakeprojectkey/airbrakeprojectkey_test.go

@@ -16,7 +16,7 @@ import (
 func TestAirbrakeProjectKey_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/airbrakeuserkey/airbrakeuserkey_test.go

@@ -16,7 +16,7 @@ import (
 func TestAirbrakeUserKey_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/airship/airship_test.go

@@ -16,7 +16,7 @@ import (
 func TestAirship_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/airtableapikey/airtableapikey_test.go

@@ -16,7 +16,7 @@ import (
 func TestAirtableApiKey_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/airvisual/airvisual_test.go

@@ -16,7 +16,7 @@ import (
 func TestAirVisual_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/alconost/alconost_test.go

@@ -16,7 +16,7 @@ import (
 func TestAlconost_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/alegra/alegra_test.go

@@ -16,7 +16,7 @@ import (
 func TestAlegra_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/aletheiaapi/aletheiaapi_test.go

@@ -16,7 +16,7 @@ import (
 func TestAletheiaApi_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/algoliaadminkey/algoliaadminkey_test.go

@@ -16,7 +16,7 @@ import (
 func TestAlgoliaAdminKey_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/alibaba/alibaba_test.go

@@ -15,7 +15,7 @@ import (
 func TestAlibaba_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/alienvault/alienvault_test.go

@@ -16,7 +16,7 @@ import (
 func TestAlienVault_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/allsports/allsports_test.go

@@ -16,7 +16,7 @@ import (
 func TestAllsports_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/amadeus/amadeus_test.go

@@ -16,7 +16,7 @@ import (
 func TestAmadeus_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/ambee/ambee_test.go

@@ -16,7 +16,7 @@ import (
 func TestAmbee_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/amplitudeapikey/amplitudeapikey_test.go

@@ -16,7 +16,7 @@ import (
 func TestAmplitudeApiKey_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/anypoint/anypoint_test.go

@@ -16,7 +16,7 @@ import (
 func TestAnypoint_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/apacta/apacta_test.go

@@ -16,7 +16,7 @@ import (
 func TestApacta_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/api2cart/api2cart_test.go

@@ -16,7 +16,7 @@ import (
 func TestApi2Cart_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/apideck/apideck_test.go

@@ -16,7 +16,7 @@ import (
 func TestApiDeck_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/apiflash/apiflash_test.go

@@ -16,7 +16,7 @@ import (
 func TestApiflash_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/apifonica/apifonica_test.go

@@ -16,7 +16,7 @@ import (
 func TestApifonica_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/apify/apify_test.go

@@ -16,7 +16,7 @@ import (
 func TestApify_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/apimatic/apimatic_test.go

@@ -16,7 +16,7 @@ import (
 func TestAPIMatic_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/apiscience/apiscience_test.go

@@ -16,7 +16,7 @@ import (
 func TestApiScience_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/apollo/apollo_test.go

@@ -16,7 +16,7 @@ import (
 func TestApollo_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/appcues/appcues_test.go

@@ -16,7 +16,7 @@ import (
 func TestAppcues_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/appfollow/appfollow_test.go

@@ -16,7 +16,7 @@ import (
 func TestAppfollow_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/appsynergy/appsynergy_test.go

@@ -16,7 +16,7 @@ import (
 func TestAppSynergy_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/apptivo/apptivo_test.go

@@ -16,7 +16,7 @@ import (
 func TestApptivo_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/artifactory/artifactory_test.go

@@ -16,7 +16,7 @@ import (
 func TestArtifactory_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/artsy/artsy_test.go

@@ -16,7 +16,7 @@ import (
 func TestArtsy_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/asanaoauth/asanaoauth_test.go

@@ -16,7 +16,7 @@ import (
 func TestAsanaOauth_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/asanapersonalaccesstoken/asanapersonalaccesstoken_test.go

@@ -16,7 +16,7 @@ import (
 func TestAsanaPersonalAccessToken_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/assemblyai/assemblyai_test.go

@@ -16,7 +16,7 @@ import (
 func TestAssemblyai_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/audd/audd_test.go

@@ -16,7 +16,7 @@ import (
 func TestAudd_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/auth0managementapitoken/auth0managementapitoken_test.go

@@ -16,7 +16,7 @@ import (
 func TestAuth0ManagementApiToken_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/auth0oauth/auth0oauth_test.go

@@ -16,7 +16,7 @@ import (
 func TestAuth0oauth_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/autodesk/autodesk_test.go

@@ -16,7 +16,7 @@ import (
 func TestAutodesk_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/autoklose/autoklose_test.go

@@ -16,7 +16,7 @@ import (
 func TestAutoklose_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/autopilot/autopilot_test.go

@@ -16,7 +16,7 @@ import (
 func TestAutoPilot_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/aviationstack/aviationstack_test.go

@@ -16,7 +16,7 @@ import (
 func TestAviationStack_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/aws/aws_test.go

@@ -18,7 +18,7 @@ func TestScanner_FromChunk(t *testing.T) {
 
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}
@@ -117,7 +117,7 @@ func BenchmarkFromData(benchmark *testing.B) {
 func Test_callerIdentity(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/axonaut/axonaut_test.go

@@ -16,7 +16,7 @@ import (
 func TestAxonaut_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/aylien/aylien_test.go

@@ -16,7 +16,7 @@ import (
 func TestAylien_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/ayrshare/ayrshare_test.go

@@ -16,7 +16,7 @@ import (
 func TestAyrshare_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/azure/azure_test.go

@@ -15,7 +15,7 @@ import (
 func TestAzure_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/bannerbear/bannerbear_test.go

@@ -16,7 +16,7 @@ import (
 func TestBannerbear_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/baremetrics/baremetrics_test.go

@@ -16,7 +16,7 @@ import (
 func TestBaremetrics_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/baseapiio/baseapiio_test.go

@@ -16,7 +16,7 @@ import (
 func TestBaseApiIO_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/beamer/beamer_test.go

@@ -16,7 +16,7 @@ import (
 func TestBeamer_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/beebole/beebole_test.go

@@ -16,7 +16,7 @@ import (
 func TestBeebole_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/besttime/besttime_test.go

@@ -16,7 +16,7 @@ import (
 func TestBesttime_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/billomat/billomat_test.go

@@ -16,7 +16,7 @@ import (
 func TestBillomat_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/bitbar/bitbar_test.go

@@ -16,7 +16,7 @@ import (
 func TestBitbar_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/bitcoinaverage/bitcoinaverage_test.go

@@ -16,7 +16,7 @@ import (
 func TestBitcoinAverage_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/bitfinex/bitfinex_test.go

@@ -16,7 +16,7 @@ import (
 func TestBitfinex_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/bitlyaccesstoken/bitlyaccesstoken_test.go

@@ -16,7 +16,7 @@ import (
 func TestBitLyAccessToken_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/bitmex/bitmex_test.go

@@ -16,7 +16,7 @@ import (
 func TestBitmex_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/blablabus/blablabus_test.go

@@ -16,7 +16,7 @@ import (
 func TestBlablabus_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/blazemeter/blazemeter_test.go

@@ -16,7 +16,7 @@ import (
 func TestBlazemeter_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/blitapp/blitapp_test.go

@@ -16,7 +16,7 @@ import (
 func TestBlitApp_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/blogger/blogger_test.go

@@ -16,7 +16,7 @@ import (
 func TestBlogger_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/bombbomb/bombbomb_test.go

@@ -16,7 +16,7 @@ import (
 func TestBombBomb_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/brandfetch/brandfetch_test.go

@@ -16,7 +16,7 @@ import (
 func TestBrandfetch_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/browshot/browshot_test.go

@@ -16,7 +16,7 @@ import (
 func TestBrowshot_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/buddyns/buddyns_test.go

@@ -16,7 +16,7 @@ import (
 func TestBuddyns_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/bugherd/bugherd_test.go

@@ -16,7 +16,7 @@ import (
 func TestBugherd_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/bugsnag/bugsnag_test.go

@@ -16,7 +16,7 @@ import (
 func TestBugsnag_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/buildkite/buildkite_test.go

@@ -16,7 +16,7 @@ import (
 func TestBuildkite_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/bulbul/bulbul_test.go

@@ -16,7 +16,7 @@ import (
 func TestBulbul_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/buttercms/buttercms_test.go

@@ -16,7 +16,7 @@ import (
 func TestButterCMS_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/caflou/caflou_test.go

@@ -16,7 +16,7 @@ import (
 func TestCaflou_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/calendarific/calendarific_test.go

@@ -16,7 +16,7 @@ import (
 func TestCalendarific_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/calendlyapikey/calendlyapikey_test.go

@@ -16,7 +16,7 @@ import (
 func TestCalendlyApiKey_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/calorieninja/calorieninja_test.go

@@ -16,7 +16,7 @@ import (
 func TestCalorieninja_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/campayn/campayn_test.go

@@ -16,7 +16,7 @@ import (
 func TestCampayn_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/cannyio/cannyio_test.go

@@ -16,7 +16,7 @@ import (
 func TestCannyIo_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/capsulecrm/capsulecrm_test.go

@@ -16,7 +16,7 @@ import (
 func TestCapsuleCRM_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/carboninterface/carboninterface_test.go

@@ -16,7 +16,7 @@ import (
 func TestCarbonInterface_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/cashboard/cashboard_test.go

@@ -16,7 +16,7 @@ import (
 func TestCashboard_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/censys/censys_test.go

@@ -16,7 +16,7 @@ import (
 func TestCensys_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/centralstationcrm/centralstationcrm_test.go

@@ -16,7 +16,7 @@ import (
 func TestCentralStationCRM_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/chatbot/chatbot_test.go

@@ -16,7 +16,7 @@ import (
 func TestChatbot_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners3")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors3")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/checio/checio_test.go

@@ -16,7 +16,7 @@ import (
 func TestChecIO_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/checklyhq/checklyhq_test.go

@@ -16,7 +16,7 @@ import (
 func TestChecklyHQ_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/checkout/checkout_test.go

@@ -16,7 +16,7 @@ import (
 func TestCheckout_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners1")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors1")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}

pkg/detectors/cicero/cicero_test.go

@@ -16,7 +16,7 @@ import (
 func TestCicero_FromChunk(t *testing.T) {
 	ctx, cancel := context.WithTimeout(context.Background(), time.Second*5)
 	defer cancel()
-	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "scanners2")
+	testSecrets, err := common.GetSecret(ctx, "trufflehog-testing", "detectors2")
 	if err != nil {
 		t.Fatalf("could not get test secrets from GCP: %s", err)
 	}