#!/bin/bash
set -euo pipefail

echo "Inspecting evaluator.Factory construction and use..."
rg -n -C3 'type Factory struct|func .*MustCreateNewFactory|func .*CreateNewFactory|func .*GenerateEvaluator' pkg/booleanpolicy/evaluator

echo
echo "Looking for assumptions that zero-value Factory is valid or invalid..."
rg -n -C3 'panic|nil|initialized|zero value|GenerateEvaluator' pkg/booleanpolicy/evaluator

#!/bin/bash

# Check Go version in the repository
go version 2>/dev/null || echo "Go version check not available"

# Look for any error handling around lazyFactory usage
rg -n "lazyFactory" pkg/booleanpolicy/

# Check if there's error handling for Factory creation or use
rg -n -A5 "MustCreateNewFactory" pkg/booleanpolicy/ | head -50

# Check if Factory fields are accessed in a way that requires initialization
rg -n "\.fieldToMetaPaths|\.rootType" pkg/booleanpolicy/evaluator/evaluator.go

#!/bin/bash

# Let's verify Go 1.26's sync.Once behavior with panic
# Check the Go source/documentation or create a small test

cat > /tmp/test_once_panic.go << 'EOF'
package main

import (
	"fmt"
	"sync"
)

var once sync.Once
var counter = 0

func main() {
	// First call - should panic
	fmt.Println("Call 1:")
	func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Println("  Caught panic:", r)
			}
		}()
		once.Do(func() {
			counter++
			panic("test panic")
		})
	}()

	// Second call - should retry if Once wasn't marked done
	fmt.Println("Call 2:")
	func() {
		defer func() {
			if r := recover(); r != nil {
				fmt.Println("  Caught panic:", r)
			}
		}()
		once.Do(func() {
			counter++
			fmt.Println("  Executing once.Do again, counter:", counter)
		})
	}()

	fmt.Println("Final counter:", counter)
	fmt.Println("If counter is 2, Once was NOT marked done on panic")
	fmt.Println("If counter is 1, Once WAS marked done on panic")
}
EOF

go run /tmp/test_once_panic.go 2>&1

#!/bin/bash

# Check what errors NewFactory can return
rg -n -A10 "^func NewFactory" pkg/booleanpolicy/evaluator/evaluator.go

# Check what happens when fieldToMetaPaths is nil
rg -n -B2 -A2 "fieldToMetaPaths\.Get" pkg/booleanpolicy/evaluator/

#!/bin/bash

# Check what utils.CrashOnError does
rg -n -A5 "func CrashOnError" 

# Verify that accessing nil.Get panics or errors
cat > /tmp/test_nil_map.go << 'EOF'
package main

import (
	"fmt"
)

type MetaPathMap struct {
	underlying map[string]interface{}
}

func (m *MetaPathMap) Get(key string) (interface{}, bool) {
	if m == nil {
		panic("cannot call Get on nil MetaPathMap")
	}
	val, found := m.underlying[key]
	return val, found
}

func main() {
	var nilMap *MetaPathMap
	defer func() {
		if r := recover(); r != nil {
			fmt.Println("Panic caught:", r)
		}
	}()
	nilMap.Get("test")
}
EOF

go run /tmp/test_nil_map.go 2>&1

#!/bin/bash
set -euo pipefail

echo "1) Locate all call sites of FromPks/ToParts:"
rg -n --type=go '\b(FromPks|ToParts)\s*\('

echo
echo "2) For each call site, inspect nearby PK sources/validators for separator constraints:"
rg -n --type=go -C3 'FromPks\(|ToParts\(|PrimaryKey|primary key|pk|ID|Id'

echo
echo "3) Find any existing invariant checks that disallow '#':"
rg -n --type=go 'Contains\(.+Separator|Contains\(.+"#"'

cat -n pkg/postgres/id/id.go

# Search for imports of the id package to confirm no usage
rg -n "pkg/postgres/id|from github.com/stackrox/rox/pkg/postgres/id" --type=go

# Search for any imports of the id package more broadly
rg -n 'import.*".*postgres/id"' --type=go

#!/bin/bash
# Description: Check if wrapcheck linter is configured and would flag this line

# Check if golangci-lint config exists and includes wrapcheck
if [ -f .golangci.yml ] || [ -f .golangci.yaml ]; then
  echo "=== Checking for wrapcheck linter configuration ==="
  rg -i "wrapcheck" .golangci.yml .golangci.yaml 2>/dev/null || echo "wrapcheck not found in config"
fi

# Search for other wrapcheck suppressions in the codebase to understand the pattern
echo ""
echo "=== Other wrapcheck suppressions in codebase ==="
rg "nolint:wrapcheck" --type go -C 2

#!/bin/bash
set -euo pipefail

# Verify whether repository automation references fakeworkloads-tagged test execution.
# Expected result: at least one workflow/script/Make target includes go test with fakeworkloads.
rg -n -C2 -P 'fakeworkloads|go\s+test[^\n]*-tags(?:=|\s+)[^\n]*fakeworkloads'

#!/bin/bash
set -euo pipefail

# Find CI configuration files
echo "=== Looking for CI configuration files ==="
find . -type f \( -name "Makefile" -o -name "*.yml" -o -name "*.yaml" -o -name ".circleci" \) | head -20

# Search GitHub workflows specifically
echo "=== GitHub workflow files ==="
find .github/workflows -type f -name "*.yml" -o -name "*.yaml" 2>/dev/null | head -20

# Look for Makefile targets related to testing
echo "=== Makefile test targets ==="
fd -t f "Makefile" | xargs grep -l "test" 2>/dev/null | head -5

#!/bin/bash
set -euo pipefail

# Search GitHub workflows for fakeworkloads tag in test execution
echo "=== Searching GitHub workflows for fakeworkloads ==="
grep -r "fakeworkloads" .github/workflows/ 2>/dev/null || echo "No matches found in workflows"

# Search for go test commands in workflows
echo -e "\n=== Searching for 'go test' patterns in workflows ==="
grep -r "go.*test" .github/workflows/ -A2 -B2 2>/dev/null | head -100

# Check build.yaml specifically
echo -e "\n=== Checking build.yaml for test targets ==="
cat .github/workflows/build.yaml | grep -A10 "test" | head -50

#!/bin/bash
set -euo pipefail

# Get full unit-tests.yaml to see matrix definition
echo "=== Full unit-tests.yaml (first 200 lines) ==="
head -200 .github/workflows/unit-tests.yaml

# Look for Makefile targets related to testing
echo -e "\n=== Makefile go-unit-tests target ==="
grep -A20 "^go-unit-tests" Makefile || echo "Not found in Makefile root"

# Search for Makefile in repository
echo -e "\n=== Finding Makefile files ==="
find . -name "Makefile" -type f | head -5

#!/bin/bash
set -euo pipefail

# Look for fakeworkloads-tagged Go invocations in CI/build config.
rg -n --hidden \
  --glob '.github/workflows/**' \
  --glob 'Makefile*' \
  --glob '**/*.mk' \
  --glob '**/Jenkinsfile*' \
  --glob '**/*.yaml' \
  --glob '**/*.yml' \
  'go (test|build).*(-tags[ =][^\\n]*fakeworkloads)|fakeworkloads'

#!/bin/bash
set -euo pipefail

# 1. Search for any Go test invocations in CI/build files (broader)
echo "=== Go test commands in CI/build config ==="
rg -n --hidden \
  --glob '.github/**' \
  --glob 'Makefile*' \
  --glob '**/*.mk' \
  'go test' \
  | head -20

# 2. Search for any mention of fakeworkloads anywhere in the repo
echo -e "\n=== All mentions of fakeworkloads ==="
rg -n --type go 'fakeworkloads' | head -30

# 3. Check if virtualmachines_test.go file exists and is newly tagged
echo -e "\n=== virtualmachines_test.go file check ==="
find . -name 'virtualmachines_test.go' -type f 2>/dev/null | head -5

# 4. Look for any CI build/test steps that run without tag restrictions
echo -e "\n=== CI files present ==="
find .github/workflows -type f -name '*.yaml' -o -name '*.yml' 2>/dev/null | head -10

#!/bin/bash
set -euo pipefail

# 1. Search for sensor package test invocations in CI
echo "=== Sensor package tests in CI ==="
rg -n --hidden \
  --glob '.github/**' \
  'sensor' | grep -i 'test\|build' | head -20

# 2. Check git history for this specific file to see if tag is new or pre-existing
echo -e "\n=== Git log for virtualmachines_test.go (limited) ==="
git log --oneline sensor/kubernetes/fake/virtualmachines_test.go 2>/dev/null | head -10 || echo "Git history unavailable or file newly added"

# 3. Check if stub pattern was already present (examine stub.go more closely)
echo -e "\n=== Stub implementation pattern ==="
cat -n sensor/kubernetes/fake/stub.go | head -30

# 4. Look for build constraints in other test files in same package
echo -e "\n=== Build constraints in sensor/kubernetes/fake/ ==="
rg -n '^//' sensor/kubernetes/fake/ | grep -E 'build|go:' | head -20

#!/bin/bash
set -euo pipefail

# Find the sensor-integration-test target in Makefile
echo "=== sensor-integration-test Makefile target ==="
rg -A 10 'sensor-integration-test:' Makefile

# Also check if there are any other references to fakeworkloads in build/test scripts
echo -e "\n=== fakeworkloads in scripts or configs (non-Go files) ==="
rg --type sh --type yaml 'fakeworkloads' 2>/dev/null | head -20

#!/bin/bash
set -euo pipefail

# Check GOTAGS default value
echo "=== GOTAGS definition in Makefile ==="
rg -B 2 -A 2 'GOTAGS\s*=' Makefile | head -30

# Check if any CI command runs sensor/kubernetes/fake tests
echo -e "\n=== CI test paths ==="
rg 'go test.*sensor' .github/workflows/*.yaml | head -20

# Check the actual go-test.sh script to see how it handles tags
echo -e "\n=== go-test.sh script ==="
if [ -f scripts/go-test.sh ]; then
  head -50 scripts/go-test.sh
fi