feat(test): change default make test to unit,systest,core + integration2

The default `make test` (no args) previously ran --suite=all (~60+ min).
Now it runs unit,systest,core suites plus integration2 tests (~30 min)
for a faster local feedback loop.

Changes:
- Split the else branch in `test` target: SUITE set → explicit suite;
  nothing set → default (unit,systest,core + integration2)
- Add $(origin) guards on all test-* targets to prevent confusing
  variable conflicts (e.g. `make test-unit SUITE=ldbc` now errors)
- Add `test-suites` target (runs all t/ runner suites via SUITE=all)
- Add `test-everything` target (all suites + integration + integration2
  + upgrade + fuzz)
- Update TESTING.md, CONTRIBUTING.md, AGENTS.md to reflect new defaults
- Update `make help` output with new default description

Author: mlwelles

AGENTS.md

@@ -0,0 +1,16 @@
+# Repository Guidelines
+
+## Project Structure & Module Organization
+The Go module is rooted here, with entrypoints and CLI tooling under `dgraph/` for Alpha, Zero, Live, and companions. Core execution sits in `worker/`, `query/`, and `posting/`, the GraphQL adapters in `graphql/`, and shared helpers in packages like `x/` and `testutil/`. Protocol definitions live in `protos/` (regenerate via `make regenerate` inside that folder). Integration harnesses are in `t/`, broader system scenarios in `systest/`, and container assets under `contrib/` and `compose/`.
+
+## Build, Test, and Development Commands
+Use `make dgraph` to compile the Linux AMD64 binaries into `./dgraph/dgraph`, or `make install` to drop them into `$GOPATH/bin`. Run `go test ./path/to/package` for focused checks or `go test ./...` for a fast repo-wide sweep. `make test` (no args) runs the default suite (`unit,systest,core` + `integration2`, ~30 min); use `make test SUITE=all` for all t/ runner suites or `make test-everything` for every test in the repo. Keep Docker running for integration tests. When debugging version info, `make version` surfaces the embedded build metadata.
+
+## Coding Style & Naming Conventions
+Follow standard Go conventions: exported identifiers start with capitals, packages use lowercase, and tests use `TestXxx` names. Format every change with `go fmt` (or `gofmt -w`) before committing; CI runs `golangci-lint`, so keep `//nolint` waivers rare and justified. Maintain the SPDX license header block on all new source files and avoid introducing unused helpers or dead code.
+
+## Testing Guidelines
+Unit tests live beside their packages in `_test.go` files and run with `go test`. The `t/` harness drives integration clusters; add new scenarios under targeted subdirectories. `systest/` and `graphql/e2e/` capture longer system flows—mirror their layout when extending coverage. Before opening a PR, run `go test ./...` and the `t` or `systest` suites touched by your change, and include regression tests for new behaviour.
+
+## Commit & Pull Request Guidelines
+Recent history favors `type(scope): short message` commits (for example, `fix(compose): ...` or `chore: ...`). Keep commits atomic with clear intent, sign when possible, and reference issues using `Fixes #1234` when applicable. PRs should describe the motivation, summarize testing (`go test ./...`, `make test`, etc.), and call out configuration or data migrations. Include doc updates for user-facing behaviour changes and attach CLI output or screenshots if tooling UX shifts.

CONTRIBUTING.md

@@ -144,16 +144,20 @@ directory, providing control and flexibility beyond the standard Go testing fram
 The simplest way to run tests is via Make:
 
 ```bash
-# Run all tests
+# Run default tests (~30 min): unit, systest, core suites + integration2
 make test
 
+# Run every test in the repo
+make test-everything
+
 # Run specific test types
 make test-unit          # Unit tests only (no Docker)
 make test-integration2  # Integration2 tests via dgraphtest
 make test-upgrade       # Upgrade tests
 
 # Use variables for more control
 make test TAGS=integration2 PKG=systest/vector
+make test SUITE=all            # All t/ runner suites
 make test TIMEOUT=90m          # Override per-package timeout (default: 30m)
 ```
 

Makefile

@@ -79,7 +79,7 @@ dgraph-installed:
 	fi
 
 .PHONY: test
-test: dgraph-installed local-image ## Run tests (see 'make help' for options)
+test: dgraph-installed local-image ## Run tests (default: unit,systest,core + integration2)
 ifdef TAGS
 	@echo "Running tests with tags: $(TAGS)"
 	go test -v --tags="$(TAGS)" \
@@ -97,54 +97,82 @@ else
 		done
 endif
 else
-	@echo "Running test suite: $(or $(SUITE),all)"
-	$(MAKE) -C t test args="--suite=$(or $(SUITE),all) $(if $(PKG),--pkg=\"$(PKG)\") $(if $(TEST),--test=\"$(TEST)\") $(if $(TIMEOUT),--timeout=$(TIMEOUT))"
+ifdef SUITE
+	@echo "Running test suite: $(SUITE)"
+	$(MAKE) -C t test args="--suite=$(SUITE) $(if $(PKG),--pkg=\"$(PKG)\") $(if $(TEST),--test=\"$(TEST)\") $(if $(TIMEOUT),--timeout=$(TIMEOUT))"
+else
+	@echo "Running test suites: unit, systest, core"
+	$(MAKE) -C t test args="--suite=unit,systest,core $(if $(PKG),--pkg=\"$(PKG)\") $(if $(TEST),--test=\"$(TEST)\") $(if $(TIMEOUT),--timeout=$(TIMEOUT))"
+	@echo "Running integration2 tests..."
+	go test -v --tags="integration2" \
+		$(if $(TEST),--run="$(TEST)") \
+		$(if $(PKG),./$(PKG)/...,./...)
+endif
 endif
 
-.PHONY: test-all
-test-all: ## All test suites via t/ runner (i.e. 'make test SUITE=all')
+.PHONY: test-suites
+test-suites: ## All test suites via t/ runner (i.e. 'make test SUITE=all')
+	$(if $(filter command line,$(origin SUITE)),$(error SUITE= cannot be passed to test-suites; use 'make test SUITE=...' instead))
 	@SUITE=all $(MAKE) test
 
 .PHONY: test-unit
-test-unit: ## Unit tests, no Docker (i.e. 'make test SUITE=unit')
+test-unit: ## Unit tests (i.e. 'make test SUITE=unit')
+	$(if $(filter command line,$(origin SUITE)),$(error SUITE= cannot be passed to test-unit; use 'make test SUITE=...' instead))
 	@SUITE=unit $(MAKE) test
 
 .PHONY: test-core
 test-core: ## Core tests (i.e. 'make test SUITE=core')
+	$(if $(filter command line,$(origin SUITE)),$(error SUITE= cannot be passed to test-core; use 'make test SUITE=...' instead))
 	@SUITE=core $(MAKE) test
 
 .PHONY: test-integration
 test-integration: ## Integration tests (i.e. 'make test TAGS=integration')
+	$(if $(filter command line,$(origin TAGS)),$(error TAGS= cannot be passed to test-integration; use 'make test TAGS=...' instead))
 	@TAGS=integration $(MAKE) test
 
 .PHONY: test-integration2
 test-integration2: ## Integration2 tests via dgraphtest (i.e. 'make test TAGS=integration2')
+	$(if $(filter command line,$(origin TAGS)),$(error TAGS= cannot be passed to test-integration2; use 'make test TAGS=...' instead))
 	@TAGS=integration2 $(MAKE) test
 
 .PHONY: test-upgrade
 test-upgrade: ## Upgrade tests (i.e. 'make test TAGS=upgrade')
+	$(if $(filter command line,$(origin TAGS)),$(error TAGS= cannot be passed to test-upgrade; use 'make test TAGS=...' instead))
 	@TAGS=upgrade $(MAKE) test
 
 .PHONY: test-systest
 test-systest: ## System integration tests (i.e. 'make test SUITE=systest')
+	$(if $(filter command line,$(origin SUITE)),$(error SUITE= cannot be passed to test-systest; use 'make test SUITE=...' instead))
 	@SUITE=systest $(MAKE) test
 
 .PHONY: test-vector
 test-vector: ## Vector search tests (i.e. 'make test SUITE=vector')
+	$(if $(filter command line,$(origin SUITE)),$(error SUITE= cannot be passed to test-vector; use 'make test SUITE=...' instead))
 	@SUITE=vector $(MAKE) test
 
 .PHONY: test-fuzz
-test-fuzz: ## Fuzz tests, auto-discovers packages (i.e. 'make test FUZZ=1')
+test-fuzz: ## Fuzz tests (i.e. 'make test FUZZ=1')
+	$(if $(filter command line,$(origin FUZZ)),$(error FUZZ= cannot be passed to test-fuzz; use 'make test FUZZ=...' instead))
 	@FUZZ=1 $(MAKE) test
 
 .PHONY: test-ldbc
 test-ldbc: ## LDBC benchmark tests (i.e. 'make test SUITE=ldbc')
+	$(if $(filter command line,$(origin SUITE)),$(error SUITE= cannot be passed to test-ldbc; use 'make test SUITE=...' instead))
 	@SUITE=ldbc $(MAKE) test
 
 .PHONY: test-load
 test-load: ## Heavy load tests (i.e. 'make test SUITE=load')
+	$(if $(filter command line,$(origin SUITE)),$(error SUITE= cannot be passed to test-load; use 'make test SUITE=...' instead))
 	@SUITE=load $(MAKE) test
 
+.PHONY: test-everything
+test-everything: ## Every test: all suites + integration + integration2 + upgrade + fuzz
+	$(MAKE) test-suites
+	$(MAKE) test-integration
+	$(MAKE) test-integration2
+	$(MAKE) test-upgrade
+	$(MAKE) test-fuzz
+
 .PHONY: test-benchmark
 test-benchmark: ## Go benchmarks (i.e. 'go test -bench')
 	go test -bench=. -benchmem $(if $(PKG),./$(PKG)/...,./...)
@@ -201,7 +229,7 @@ help: ## Show available targets and variables
 		awk 'BEGIN {FS = ":.*?## "}; {printf "  %-20s %s\n", $$1, $$2}'
 	@echo ""
 	@echo "Variables that can be passed to 'test':"
-	@echo "  SUITE     Select t/ runner suite (e.g., make test SUITE=systest)"
+	@echo "  SUITE     Select t/ runner suite (default: unit,systest,core + integration2)"
 	@echo "  TAGS      Go build tags - bypasses t/ runner (e.g., make test TAGS=integration2)"
 	@echo "  PKG       Limit to specific package (e.g., make test PKG=systest/export)"
 	@echo "  TEST      Run specific test function (e.g., make test TEST=TestGQLSchema)"

TESTING.md

@@ -304,12 +304,15 @@ If both pass, you're ready to run all test types!
 The simplest way to run tests:
 
 ```bash
-# Run all tests (default)
+# Run default tests (~30 min): unit, systest, core suites + integration2
 make test
 
+# Run every test in the repo (all suites + all tag-based tests + fuzz)
+make test-everything
+
 # Common shortcuts (run 'make help' for full list)
-make test-all           # All test suites via t/ runner (i.e. 'make test SUITE=all')
-make test-unit          # Unit tests, no Docker (i.e. 'make test SUITE=unit')
+make test-suites        # All t/ runner suites (i.e. 'make test SUITE=all')
+make test-unit          # Unit tests (i.e. 'make test SUITE=unit')
 make test-core          # Core tests (i.e. 'make test SUITE=core')
 make test-systest       # System integration tests (i.e. 'make test SUITE=systest')
 make test-vector        # Vector search tests (i.e. 'make test SUITE=vector')
@@ -318,7 +321,7 @@ make test-load          # Heavy load tests (i.e. 'make test SUITE=load')
 make test-integration   # Integration tests (i.e. 'make test TAGS=integration')
 make test-integration2  # Integration2 tests via dgraphtest (i.e. 'make test TAGS=integration2')
 make test-upgrade       # Upgrade tests (i.e. 'make test TAGS=upgrade')
-make test-fuzz          # Fuzz tests, auto-discovers packages (i.e. 'make test FUZZ=1')
+make test-fuzz          # Fuzz tests (i.e. 'make test FUZZ=1')
 make test-benchmark     # Go benchmarks (i.e. 'go test -bench')
 ```
 
@@ -339,7 +342,8 @@ For more control, pass variables to `make test`:
 | `FUZZ`     | Enable fuzz testing                | `make test FUZZ=1`              |
 | `FUZZTIME` | Fuzz duration per package          | `make test FUZZ=1 FUZZTIME=60s` |
 
-**Precedence:** `TAGS` > `FUZZ` > `SUITE` (first match wins)
+**Precedence:** `TAGS` > `FUZZ` > `SUITE` > default (first match wins). When no
+variable is set, `make test` runs suites `unit,systest,core` plus `integration2`.
 
 ### Examples
 
@@ -1288,6 +1292,8 @@ The following items from the original wishlist have been implemented:
 
 - **✅ Unified test interface:** A single `make test` entry point that accepts arguments to run any
   test type (unit, integration, integration2, upgrade, fuzz) with environment variables for control.
+  The default (`make test` with no args) runs `unit,systest,core` suites plus `integration2` for a
+  fast feedback loop (~30 min). Use `make test-everything` to run all tests.
 
 - **✅ Example commands that "just work":** The following now work as expected: