netjes 0.0.1 → 0.0.3

package/template/tests/__NAME__.Tests/AppFactory.cs

@@ -0,0 +1,31 @@
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.AspNetCore.Mvc.Testing;
+using Microsoft.Extensions.DependencyInjection;
+using Netjes.Rendering;
+
+namespace __NAME__.Tests;
+
+/// <summary>Runs the real app in memory, with its pipeline and services, and without a client build or Node.</summary>
+public sealed class AppFactory : WebApplicationFactory<Program>
+{
+    protected override void ConfigureWebHost(IWebHostBuilder builder)
+    {
+        // Not Development: there Netjes output-caches no page, so a test of CachePage would see every request render.
+        builder.UseEnvironment("Testing");
+        // Development mode reads the routes from app/ on disk; nothing is rendered, so no Vite or Node is needed.
+        builder.UseSetting("Netjes:Mode", "Development");
+        builder.ConfigureServices(services =>
+        {
+            services.AddSingleton<ISsrRenderer, FixedHtml>();
+            // Development mode would rewrite generated/netjes.ts: a test run leaves it as it is, for `netjes generate --check`.
+            services.Configure<NetjesOptions>(options => options.TypesFile = null);
+        });
+    }
+
+    /// <summary>Stands in for the Node process: a document request gets this HTML. A payload request goes through no renderer.</summary>
+    private sealed class FixedHtml : ISsrRenderer
+    {
+        public Task<string> RenderAsync(string payloadJson, CancellationToken cancellationToken) =>
+            Task.FromResult("<!DOCTYPE html><html><body>rendered</body></html>");
+    }
+}

package/template/tests/__NAME__.Tests/HomePageTests.cs

@@ -0,0 +1,55 @@
+using System.Net;
+using System.Text.Json.Nodes;
+
+namespace __NAME__.Tests;
+
+/// <summary>The home page's loader and server action (Features/Home/HomePage.cs), requested as the client router does.</summary>
+public sealed class HomePageTests(AppFactory app) : IClassFixture<AppFactory>
+{
+    [Fact]
+    public async ValueTask TheHomePage_HasTheLoadersMessage()
+    {
+        var client = app.CreateClient();
+        client.DefaultRequestHeaders.Add(NetjesHeaders.Data, "1");
+
+        var response = await client.GetAsync("/", TestContext.Current.CancellationToken);
+        var payload = JsonNode.Parse(await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken))!;
+
+        Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+        Assert.Equal("Hello from C#", (string?)payload["props"]!["message"]);
+    }
+
+    [Fact]
+    public async ValueTask Greeting_WithoutAName_IsAFieldError()
+    {
+        var (status, result) = await Greet("");
+
+        Assert.Equal(HttpStatusCode.UnprocessableEntity, status);
+        Assert.Equal("Tell us your name.", (string?)result["errors"]!["name"]![0]);
+    }
+
+    [Fact]
+    public async ValueTask Greeting_WithAName_SaysHello()
+    {
+        var (status, result) = await Greet("Ada");
+
+        Assert.Equal(HttpStatusCode.OK, status);
+        Assert.Equal("Hello, Ada!", (string?)result["result"]!["text"]);
+    }
+
+    /// <summary>Posts the form with an antiforgery token: the header takes the token, the client's cookies its cookie.</summary>
+    private async Task<(HttpStatusCode, JsonNode)> Greet(string name)
+    {
+        var client = app.CreateClient();
+        var token = JsonNode.Parse(await client.GetStringAsync("/_netjes/antiforgery", TestContext.Current.CancellationToken))!;
+        client.DefaultRequestHeaders.Add(NetjesHeaders.Data, "1");
+        client.DefaultRequestHeaders.Add((string)token["headerName"]!, (string)token["requestToken"]!);
+
+        var response = await client.PostAsync(
+            "/_netjes/actions/home.greet",
+            new FormUrlEncodedContent([new("name", name)]),
+            TestContext.Current.CancellationToken);
+
+        return (response.StatusCode, JsonNode.Parse(await response.Content.ReadAsStringAsync(TestContext.Current.CancellationToken))!);
+    }
+}

package/template/tests/__NAME__.Tests/__NAME__.Tests.csproj

@@ -0,0 +1,30 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <Nullable>enable</Nullable>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <TreatWarningsAsErrors>true</TreatWarningsAsErrors>
+    <IsPackable>false</IsPackable>
+    <OutputType>Exe</OutputType>
+  </PropertyGroup>
+
+  <!-- xunit.v3.mtp-off is xUnit v3 for dotnet test's default runner, VSTest, which works in any folder. In a repository
+       whose global.json selects Microsoft.Testing.Platform as the test runner, reference xunit.v3 in its place. -->
+  <ItemGroup>
+    <PackageReference Include="Microsoft.AspNetCore.Mvc.Testing" Version="10.0.14" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="18.11.0" />
+    <PackageReference Include="xunit.v3.mtp-off" Version="4.0.2" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="4.0.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="../../__NAME__.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Netjes" />
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>

package/template/tsconfig.app.json

@@ -0,0 +1,20 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "lib": ["ES2023", "DOM", "DOM.Iterable"],
+    "types": ["vite/client"],
+    "jsx": "react-jsx",
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "isolatedModules": true,
+    "verbatimModuleSyntax": true,
+    "allowImportingTsExtensions": true,
+    "skipLibCheck": true,
+    "noEmit": true
+  },
+  "include": ["**/*.ts", "**/*.tsx"],
+  "exclude": ["node_modules", "dist", "**/bin", "**/obj", "publish", "out", "e2e", "scripts", "vite.config.ts", "playwright.config.ts"]
+}

package/template/tsconfig.json

@@ -1,19 +1,4 @@
 {
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "lib": ["ES2023", "DOM", "DOM.Iterable"],
-    "types": ["vite/client"],
-    "jsx": "react-jsx",
-    "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "noImplicitOverride": true,
-    "isolatedModules": true,
-    "verbatimModuleSyntax": true,
-    "allowImportingTsExtensions": true,
-    "skipLibCheck": true,
-    "noEmit": true
-  },
-  "include": ["app", "components", "generated", "vite.config.ts"]
+  "files": [],
+  "references": [{ "path": "./tsconfig.app.json" }, { "path": "./tsconfig.node.json" }]
 }

package/template/tsconfig.node.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.app.json",
+  "compilerOptions": {
+    "types": ["node"]
+  },
+  "include": ["vite.config.ts", "playwright.config.ts", "e2e", "scripts"],
+  "exclude": ["node_modules"]
+}

package/vite/plugin.d.ts

@@ -19,9 +19,17 @@ export type NetjesPluginOptions = {
    * The built-in TanStack Query client, seeded from C# with `PageResult.WithQuery`. Default true. `false` removes it
    * (and TanStack Query from the bundle); an object configures it. Options are written into the bundle as literals,
    * so plain values (numbers including Infinity, strings, booleans, objects, arrays) work and functions are rejected.
+   * In tests, unless `test` is false, `createTestApp()` from `netjes/testing` starts from the same `defaultOptions`,
+   * except `retryDelay` and the queries' `gcTime`.
    */
   query?: boolean | { defaultOptions?: DefaultOptions };
-  /** Vitest defaults (jsdom, Testing Library cleanup, no e2e/ or build output). Default true; the app's own `test` settings win. */
+  /**
+   * Vitest defaults (jsdom, Testing Library cleanup, no e2e/ or build output), each only where the app's own `test`
+   * settings leave it unset, with two exceptions that are added to what the app sets: Netjes's own setup file, after
+   * the app's own `setupFiles`, and `provide['netjes:query']`, the `query` option's `defaultOptions` for
+   * `createTestApp()` (none with `query: false`). Default true; `false` adds none of them. Under Vitest 5, inline
+   * `test.projects` that share the root's Vite server get none of them unless the root sets `sharedViteServer: false`.
+   */
   test?: boolean;
 };
 

package/vite/plugin.mjs

@@ -15,6 +15,8 @@ const SERVER_ENTRY = normalizePath(fileURLToPath(new URL('../dist/server-entry.j
 const SIDECAR = fileURLToPath(new URL('../sidecar/server.mjs', import.meta.url));
 const QUERY_MODULE = normalizePath(fileURLToPath(new URL('../dist/query.js', import.meta.url)));
 const TEST_SETUP = normalizePath(fileURLToPath(new URL('../dist/testing-setup.js', import.meta.url)));
+// What the test harness needs from Vitest: the setup file every app's tests get, after the app's own. Not exported.
+const TEST_VITEST = normalizePath(fileURLToPath(new URL('../dist/testing-vitest.js', import.meta.url)));
 
 const PAGES_ID = 'virtual:netjes/pages';
 const RESOLVED_PAGES_ID = `\0${PAGES_ID}`;
@@ -72,18 +74,27 @@ function canResolve(root, name) {
 
 /**
  * Vitest settings for component tests, unless the app set them itself: a DOM (when jsdom is installed), Testing
- * Library cleanup (when it is installed), and no Playwright specs (e2e/), build output or .NET bin/obj folders.
+ * Library cleanup (when it is installed), and no Playwright specs (e2e/), build output or .NET bin/obj folders. Two
+ * exceptions, which Vite merges into what the app set: Netjes's own setup file goes into every app's setupFiles,
+ * after the app's own, and provide['netjes:query'] holds the app's query defaultOptions, which that file hands to
+ * createTestApp. Only that key is returned, so the app's own provide keys are not merged twice. Vitest 5 builds the
+ * test options of an inline test project that shares the root's Vite server from the root's options as written, before
+ * this hook runs, so such a project gets none of these; with sharedViteServer: false it resolves the config, and this
+ * hook, for each project.
  * @param {Record<string, unknown> | undefined} test
  * @param {string} root
+ * @param {{ defaultOptions?: import('@tanstack/react-query').DefaultOptions } | null} query
  */
-function testDefaults(test = {}, root) {
+function testDefaults(test = {}, root, query) {
   /** @type {Record<string, unknown>} */
   const defaults = {};
   if (test.environment === undefined && canResolve(root, 'jsdom')) defaults.environment = 'jsdom';
   if (test.exclude === undefined) {
     defaults.exclude = ['**/node_modules/**', '**/dist/**', '**/bin/**', '**/obj/**', '**/e2e/**', '**/.git/**'];
   }
-  if (test.setupFiles === undefined && canResolve(root, '@testing-library/react')) defaults.setupFiles = [TEST_SETUP];
+  const cleanup = test.setupFiles === undefined && canResolve(root, '@testing-library/react');
+  defaults.setupFiles = cleanup ? [TEST_SETUP, TEST_VITEST] : [TEST_VITEST];
+  if (query) defaults.provide = { 'netjes:query': query.defaultOptions ?? {} };
   return defaults;
 }
 
@@ -174,7 +185,7 @@ export default function netjes(options = {}) {
       const userTest = /** @type {{ test?: Record<string, unknown> }} */ (/** @type {unknown} */ (config)).test;
       const root = path.resolve(config.root ?? process.cwd());
       const workspaceRoot = searchForWorkspaceRoot(root);
-      const test = env.command === 'serve' && options.test !== false ? { test: testDefaults(userTest, root) } : {};
+      const test = env.command === 'serve' && options.test !== false ? { test: testDefaults(userTest, root, query) } : {};
       // Built asset URLs live under the base path; in development the browser loads modules from the Vite server's root.
       const base = env.command === 'build' && basePath ? { base: `${basePath}/` } : {};
       return {
@@ -278,7 +289,8 @@ export default function netjes(options = {}) {
       }
       if (id !== RESOLVED_PAGES_ID) return undefined;
       const glob = JSON.stringify([appFiles]);
-      return `export const pages = import.meta.glob(${glob});\n`;
+      // The folder the keys start with: renderDocument (netjes/testing) builds routes and segment ids from it.
+      return `export const pages = import.meta.glob(${glob});\nexport const appDir = ${JSON.stringify(appDir)};\n`;
     },
     async writeBundle() {
       if (!isSsrBuild) return;