Enhance "Introduction" pages in docs

Author: roxblnfk

CLAUDE.md

@@ -103,7 +103,7 @@ llms_description: "Technical description of what LLM learns from this page"
 
 **Guidelines for `llms_description`:**
 - List specific classes, attributes, methods — not vague descriptions
-- Example: `"#[BeforeEach], #[AfterEach], #[BeforeAll], #[AfterAll] lifecycle hooks, execution order, priority"`
+- Example: `"#[BeforeTest], #[AfterTest], #[BeforeClass], #[AfterClass] lifecycle hooks, execution order, priority"`
 - NOT: `"Learn about test lifecycle management"`
 
 **When adding new doc pages:** add `llms_description` to the English version frontmatter. Do NOT add llms frontmatter to blog posts.

docs/getting-started.md

@@ -71,33 +71,7 @@ final class MyFirstTest
 }
 ```
 
-The `#[Test]` attribute marks the method as a test, and the `Assert` facade checks assertions.
-Testo supports a wide range of assertions via `Assert` and expectations via `Expect`.
-
-Use attributes to extend test functionality.
-For example, `#[Retry]` retries a test on failure, and `#[ExpectException]` expects a specific exception:
-
-```php
-#[Test]
-final class MyFirstTest
-{
-    #[Retry(maxAttempts: 5)] // Retries up to 5 times if test fails
-    public function flakyTest(): void
-    {
-        Assert::same(mt_rand(0, 2), 2);
-    }
-
-    #[ExpectException(\RuntimeException::class)]
-    public function throwsException(): never
-    {
-        throw new \RuntimeException('Expected error');
-    }
-}
-```
-
-::: question Why `#[Test]` on a class?
-You can put `#[Test]` on a class — then all public methods with return type `void` or `never` become tests.
-:::
+The `#[Test]` attribute marks the method as a test, and the `Assert` facade checks assertions. More about test approaches, attributes, and conventions — in [Writing Tests](writing-tests.md).
 
 ## Running Tests
 

docs/plugins/lifecycle.md

@@ -1,5 +1,5 @@
 ---
-llms_description: "#[BeforeEach], #[AfterEach], #[BeforeAll], #[AfterAll] lifecycle hooks, execution order, priority, class instantiation behavior"
+llms_description: "#[BeforeTest], #[AfterTest], #[BeforeClass], #[AfterClass] lifecycle hooks, execution order, priority, class instantiation behavior"
 ---
 
 # Lifecycle
@@ -51,25 +51,25 @@ To control state between tests, use lifecycle attributes described below.
 
 ## Attributes
 
-| Attribute | When it runs | How often |
-|-----------|--------------|-----------|
-| `#[BeforeEach]` | Before each test method | Once per test |
-| `#[AfterEach]` | After each test method | Once per test |
-| `#[BeforeAll]` | Before all tests in the class | Once per test case |
-| `#[AfterAll]` | After all tests in the class | Once per test case |
+| Attribute        | When it runs                  | How often          |
+|------------------|-------------------------------|--------------------|
+| `#[BeforeTest]`  | Before each test method       | Once per test      |
+| `#[AfterTest]`   | After each test method        | Once per test      |
+| `#[BeforeClass]` | Before all tests in the class | Once per test case |
+| `#[AfterClass]`  | After all tests in the class  | Once per test case |
 
 ## Execution Order
 
 ```
-BeforeAll (once)
-├── BeforeEach
+BeforeClass (once)
+├── BeforeTest
 │   └── Test 1
-│   └── AfterEach
-├── BeforeEach
+│   └── AfterTest
+├── BeforeTest
 │   └── Test 2
-│   └── AfterEach
+│   └── AfterTest
 └── ...
-AfterAll (once)
+AfterClass (once)
 ```
 
 ## Basic Example
@@ -80,25 +80,25 @@ final class DatabaseTest
     private static Connection $connection;
     private Transaction $transaction;
 
-    #[BeforeAll]
+    #[BeforeClass]
     public static function connect(): void
     {
         self::$connection = new Connection();
     }
 
-    #[AfterAll]
+    #[AfterClass]
     public static function disconnect(): void
     {
         self::$connection->close();
     }
 
-    #[BeforeEach]
+    #[BeforeTest]
     public function beginTransaction(): void
     {
         $this->transaction = self::$connection->beginTransaction();
     }
 
-    #[AfterEach]
+    #[AfterTest]
     public function rollback(): void
     {
         $this->transaction->rollback();
@@ -118,30 +118,23 @@ final class DatabaseTest
 When you have multiple methods with the same lifecycle attribute, use `priority` to control execution order:
 
 ```php
-#[BeforeEach(priority: 100)]
+#[BeforeTest(priority: 100)]
 public function initializeConfig(): void
 {
     // Runs first (highest priority)
 }
 
-#[BeforeEach(priority: 50)]
+#[BeforeTest(priority: 50)]
 public function initializeLogger(): void
 {
     // Runs second
 }
 
-#[BeforeEach] // priority: 0 (default)
+#[BeforeTest] // priority: 0 (default)
 public function initializeService(): void
 {
     // Runs last
 }
 ```
 
 Higher values execute first. Default priority is `0`.
-
-## Error Handling
-
-- Exception in `BeforeEach` — test is aborted
-- Exception in `AfterEach` — captured, but test result is preserved
-- Exception in `BeforeAll` — all tests in the class are aborted
-- Exception in `AfterAll` — captured after all tests complete

docs/plugins/test.md

@@ -8,33 +8,44 @@ The `#[Test]` attribute explicitly marks a method, function, or class as a test.
 
 Can be placed on:
 
-- **Class** — all public methods with `void` return type become tests
+- **Class** — all public methods with `void` or `never` return type become tests
 - **Method** — only that method is a test
 - **Function** — the function is a test
 
-```php
+::: code-group
+```php [#[Test] on class]
+// tests/Unit/Order.php
 #[Test]
-final class OrderTest
+final class Order
 {
     public function createsOrder(): void { /* ... */ }
 
     public function calculatesTotal(): void { /* ... */ }
-
-    public function appliesDiscount(): void { /* ... */ }
 }
-
-final class UserTest
+```
+```php [#[Test] on method]
+// tests/Unit/Order.php
+final class Order
 {
     #[Test]
-    public function validatesEmail(): void { /* ... */ }
+    public function createsOrder(): void { /* ... */ }
 
     #[Test]
-    public function checksPermissions(): void { /* ... */ }
+    public function calculatesTotal(): void { /* ... */ }
 }
+```
+```php [Function]
+// tests/Unit/order.php
+#[Test]
+function creates_order(): void { /* ... */ }
+
+#[Test]
+function calculates_total(): void { /* ... */ }
 
 #[Test]
-function checks_environment(): void { /* ... */ }
+function applies_discount(): void { /* ... */ }
 ```
+:::
 
 ## When to Use
 

docs/why-testo.md

@@ -21,7 +21,7 @@ Testo was born from the need for an extensible testing framework that could adap
 
 ## Testo Philosophy
 
-### Developer's Full Control
+### Full Control for the Developer
 
 From Testo's perspective, **tests are the developer's property, not the framework's**. All metadata and operational data needed by the framework are stored and processed separately.
 
@@ -43,18 +43,19 @@ function simpleTest(): void
 
 Testo is built on a simple idea: **a small core with a set of DTOs and contracts, and all functionality is built on top of middleware and event system**.
 
-The core simply builds several pipelines from middleware, and then do whatever you want. Every framework feature is middleware or event handlers:
+The core simply builds several pipelines from middleware, and then do whatever you want. Every framework feature is middleware or event handlers, packaged into a plugin:
 - Attributes in general
 - Data providers
 - Inline testing
 - Assertion system (`Assert`, `Expect`)
 - CLI rendering and TeamCity
+- ...
 
 ### Well-Designed API
 
-Instead of a bloated `Assert` facade with ~2300 lines (as in PHPUnit), Testo provides:
-- **`Assert`** — for assertions (checked here and now)
-- **`Expect`** — for expectations (checked after test completion)
+Instead of a bloated `Assert` facade, Testo provides:
+- **`Assert`** — for assertions (checked here and now).
+- **`Expect`** — for expectations (checked after test completion).
 - **Pipe assertions** — grouping by types for cleaner code:
 
 ```php
@@ -74,12 +75,15 @@ Testo comes with a [PhpStorm/IntelliJ IDEA plugin](https://plugins.jetbrains.com
 
 ## Who Is Testo For?
 
-Testo is built for those who:
-- Develop **frameworks** and need deep test integration.
-- Create **SDKs** with specific testing requirements.
-- Build **complex systems** where PHPUnit doesn't provide the needed flexibility.
-- Want **full control** over testing infrastructure.
-- Prefer PHP syntax over JS.
+Testo is for anyone who loves PHP.
+
+Open-source developers can count on support for [current PHP versions](https://www.php.net/supported-versions.php).
+Framework and SDK authors get a powerful tool for building their own test environments through Testo integration.
+
+Developers on projects get clean tests without needing to learn new syntactic constructs or concepts.
+Flexible settings and the plugin system allow adapting Testo to any project requirements, from simple unit tests to complex integration scenarios.
+
+After all, I'm a framework, SDK, and high-load project developer myself, so I know all these pains firsthand.
 
 ## What's Next?