@contractkit/plugin-csharp 0.0.0

package/tests/hoist.test.ts

@@ -0,0 +1,92 @@
+import { describe, expect, it } from 'vitest';
+import { buildModelIndex } from '@contractkit/core';
+import type { ContractRootNode } from '@contractkit/core';
+import { collectHoistedTypes } from '../src/hoist.js';
+import { contractRoot, enumType, field, inlineObjectType, literalType, model, refType, scalarType, tupleType, unionType } from './helpers.js';
+
+function hoist(roots: ContractRootNode[], modelsWithInput = new Set<string>(), warn?: (m: string, f: string) => void) {
+    return collectHoistedTypes(roots, { modelIndex: buildModelIndex(roots.flatMap(r => r.models)), modelsWithInput, warn });
+}
+
+describe('collectHoistedTypes', () => {
+    it('names an inline enum after the model and field that hold it', () => {
+        const result = hoist([contractRoot([model('M', [field('status', enumType('a', 'b'))])])]);
+        expect(result.byName.get('MStatus')?.kind).toBe('enum');
+    });
+
+    it('names an inline object as a record', () => {
+        const result = hoist([contractRoot([model('M', [field('nested', inlineObjectType([field('a', scalarType('string'))]))])])]);
+        expect(result.byName.get('MNested')?.kind).toBe('record');
+    });
+
+    it('hoists a 2-tuple, which the Kotlin plugin maps onto Pair instead', () => {
+        const result = hoist([contractRoot([model('M', [field('coords', tupleType(scalarType('int'), scalarType('int')))])])]);
+        expect(result.byName.get('MCoords')?.kind).toBe('tuple');
+    });
+
+    it('leaves a union of one non-null member alone, since that is just a nullable type', () => {
+        const result = hoist([contractRoot([model('M', [field('v', unionType(scalarType('string'), scalarType('null')))])])]);
+        expect(result.byName.has('MV')).toBe(false);
+    });
+
+    it('records a membership so a member record declares the union it belongs to', () => {
+        const result = hoist([
+            contractRoot([
+                model('Card', [field('kind', literalType('card'))]),
+                model('M', [field('m', { kind: 'discriminatedUnion', discriminator: 'kind', members: [refType('Card')] })]),
+            ]),
+        ]);
+        expect(result.memberships.get('Card')).toEqual(['MM']);
+    });
+
+    it('lets one contract belong to two unions, which a record base could not express', () => {
+        const result = hoist([
+            contractRoot([
+                model('Card', [field('kind', literalType('card'))]),
+                model('A', [field('m', { kind: 'discriminatedUnion', discriminator: 'kind', members: [refType('Card')] })]),
+                model('B', [field('m', { kind: 'discriminatedUnion', discriminator: 'kind', members: [refType('Card')] })]),
+            ]),
+        ]);
+        expect(result.memberships.get('Card')).toEqual(['AM', 'BM']);
+    });
+
+    it('suffixes a name already claimed by a model', () => {
+        const result = hoist([contractRoot([model('MStatus', [field('x', scalarType('string'))]), model('M', [field('status', enumType('a'))])])]);
+        expect(result.byName.has('MStatus2')).toBe(true);
+    });
+
+    it('warns and hoists nothing when a discriminator is not a literal', () => {
+        const warnings: string[] = [];
+        const result = hoist(
+            [
+                contractRoot([
+                    model('Card', [field('kind', enumType('card'))]),
+                    model('M', [field('m', { kind: 'discriminatedUnion', discriminator: 'kind', members: [refType('Card')] })]),
+                ]),
+            ],
+            new Set(),
+            m => warnings.push(m),
+        );
+        expect(result.byName.has('MM')).toBe(false);
+        expect(warnings.join('\n')).toMatch(/is not a literal/);
+    });
+
+    it('marks a hoisted shape as needing an Input twin when it reaches a split model', () => {
+        const roots = [
+            contractRoot([
+                model('P', [field('id', scalarType('uuid'), { visibility: 'readonly' })]),
+                model('M', [field('nested', inlineObjectType([field('p', refType('P'))]))]),
+            ]),
+        ];
+        const result = hoist(roots, new Set(['P']));
+        expect(result.byName.get('MNested')?.needsInput).toBe(true);
+    });
+
+    it('assigns a declaration to the file that owns it, so each models file emits its own', () => {
+        const a = contractRoot([model('A', [field('s', enumType('x'))])], 'a.ck');
+        const b = contractRoot([model('B', [field('s', enumType('y'))])], 'b.ck');
+        const result = hoist([a, b]);
+        expect(result.byFile.get('a.ck')?.map(d => d.name)).toEqual(['AS']);
+        expect(result.byFile.get('b.ck')?.map(d => d.name)).toEqual(['BS']);
+    });
+});

package/tests/index.test.ts

@@ -0,0 +1,124 @@
+import { mkdtempSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, relative, sep } from 'node:path';
+import { describe, expect, it } from 'vitest';
+import type { PluginContext } from '@contractkit/core';
+import { assertValidConfig, createCSharpSdkPlugin } from '../src/index.js';
+import { contractRoot, field, model, opOperation, opResponse, opRoot, opRoute, scalarType } from './helpers.js';
+
+const ROOT_DIR = '/project';
+
+/** A `PluginContext` that captures `emitFile` in memory, keyed by rootDir-relative POSIX path. */
+export function makeCtx(): PluginContext & { emitted: Map<string, string>; ifAbsent: string[] } {
+    const emitted = new Map<string, string>();
+    const ifAbsent: string[] = [];
+    return {
+        rootDir: ROOT_DIR,
+        options: {},
+        cacheEnabled: false,
+        cacheDir: mkdtempSync(join(tmpdir(), 'ck-csharp-')),
+        emitFile: (outPath, content, opts) => {
+            const key = relative(ROOT_DIR, outPath).split(sep).join('/');
+            emitted.set(key, content);
+            if (opts?.ifAbsent) ifAbsent.push(key);
+        },
+        emitted,
+        ifAbsent,
+    };
+}
+
+export const INPUTS = {
+    contractRoots: [contractRoot([model('Payment', [field('id', scalarType('uuid'))])], 'contracts/billing.ck')],
+    opRoots: [
+        opRoot(
+            [opRoute('/payments', [opOperation('get', { sdk: 'listPayments', responses: [opResponse(200, 'Payment')] })])],
+            'contracts/billing.ck',
+        ),
+    ],
+    modelsWithInput: new Set<string>(),
+    modelsWithOutput: new Set<string>(),
+};
+
+describe('assertValidConfig', () => {
+    it('accepts a valid config and an empty one', () => {
+        expect(() => assertValidConfig({})).not.toThrow();
+        expect(() => assertValidConfig({ namespace: 'Acme.Sdk', sdkName: 'AcmeSdk', scaffold: true })).not.toThrow();
+    });
+
+    it('rejects a namespace segment that is not an identifier', () => {
+        expect(() => assertValidConfig({ namespace: 'Acme.1Bad' })).toThrow(/not a valid C# namespace/);
+        expect(() => assertValidConfig({ namespace: 'Acme..Sdk' })).toThrow(/not a valid C# namespace/);
+        expect(() => assertValidConfig({ namespace: 'Acme/Sdk' })).toThrow(/not a valid C# namespace/);
+    });
+
+    it('rejects a namespace segment that is a C# keyword', () => {
+        expect(() => assertValidConfig({ namespace: 'Acme.event.Sdk' })).toThrow(/contains the C# keyword 'event'/);
+    });
+
+    it('rejects an sdkName that is not a class name', () => {
+        expect(() => assertValidConfig({ sdkName: '2Sdk' })).toThrow(/not a valid C# class name/);
+        expect(() => assertValidConfig({ sdkName: 'class' })).toThrow(/is a C# keyword/);
+    });
+
+    it('rejects non-boolean flags, which JSON config cannot be trusted to type', () => {
+        expect(() => assertValidConfig({ scaffold: 'yes' as never })).toThrow(/scaffold must be a boolean/);
+        expect(() => assertValidConfig({ includeInternal: 1 as never })).toThrow(/includeInternal must be a boolean/);
+    });
+});
+
+describe('generateTargets', () => {
+    it('emits the runtime and the aggregator at the configured output directory', async () => {
+        const ctx = makeCtx();
+        const plugin = createCSharpSdkPlugin({ baseDir: 'cssdk', namespace: 'Acme.Sdk', sdkName: 'AcmeSdk' }, ROOT_DIR);
+        await plugin.generateTargets!(INPUTS, ctx);
+
+        expect([...ctx.emitted.keys()].sort()).toEqual([
+            'cssdk/AcmeSdk.cs',
+            'cssdk/Clients/BillingClient.cs',
+            'cssdk/Models/Billing.cs',
+            'cssdk/Runtime/Converters.cs',
+            'cssdk/Runtime/SdkRuntime.cs',
+        ]);
+        expect(ctx.emitted.get('cssdk/Runtime/SdkRuntime.cs')).toContain('namespace Acme.Sdk.Runtime;');
+        expect(ctx.emitted.get('cssdk/Models/Billing.cs')).toContain('public sealed record Payment');
+        expect(ctx.emitted.get('cssdk/Clients/BillingClient.cs')).toContain('public sealed class BillingClient(SdkHttp http)');
+        expect(ctx.emitted.get('cssdk/AcmeSdk.cs')).toContain('public sealed class AcmeSdk : IDisposable');
+        expect(ctx.emitted.get('cssdk/AcmeSdk.cs')).toContain('Billing = new BillingClient(Http);');
+    });
+
+    it('defaults the output directory, namespace, and aggregator name', async () => {
+        const ctx = makeCtx();
+        await createCSharpSdkPlugin({}, ROOT_DIR).generateTargets!(INPUTS, ctx);
+        expect(ctx.emitted.has('csharp-sdk/Sdk.cs')).toBe(true);
+        expect(ctx.emitted.get('csharp-sdk/Sdk.cs')).toContain('namespace ContractKit.Sdk;');
+    });
+
+    it('skips a client file whose operations are all internal, rather than emitting an empty class', async () => {
+        const ctx = makeCtx();
+        const internalOnly = {
+            ...INPUTS,
+            opRoots: [opRoot([opRoute('/x', [opOperation('get', { sdk: 'x' })], undefined, ['internal'])], 'contracts/admin.ck')],
+        };
+        await createCSharpSdkPlugin({ baseDir: 'cssdk', namespace: 'Acme.Sdk' }, ROOT_DIR).generateTargets!(internalOnly, ctx);
+        expect([...ctx.emitted.keys()].some(k => k.includes('AdminClient'))).toBe(false);
+    });
+
+    it('emits the project file as user-owned only when scaffolding is asked for', async () => {
+        const off = makeCtx();
+        await createCSharpSdkPlugin({ baseDir: 'cssdk', sdkName: 'AcmeSdk' }, ROOT_DIR).generateTargets!(INPUTS, off);
+        expect(off.emitted.has('cssdk/AcmeSdk.csproj')).toBe(false);
+
+        const on = makeCtx();
+        await createCSharpSdkPlugin({ baseDir: 'cssdk', sdkName: 'AcmeSdk', scaffold: true }, ROOT_DIR).generateTargets!(INPUTS, on);
+        expect(on.emitted.get('cssdk/AcmeSdk.csproj')).toContain('<AssemblyName>AcmeSdk</AssemblyName>');
+        // Write-once: the CLI must be told not to overwrite a file the user has since edited.
+        expect(on.ifAbsent).toEqual(['cssdk/AcmeSdk.csproj']);
+    });
+
+    it('surfaces an invalid namespace as a build error rather than emitting broken C#', async () => {
+        const ctx = makeCtx();
+        const plugin = createCSharpSdkPlugin({ namespace: 'Acme.class.Sdk' }, ROOT_DIR);
+        await expect(plugin.generateTargets!(INPUTS, ctx)).rejects.toThrow(/C# keyword 'class'/);
+        expect(ctx.emitted.size).toBe(0);
+    });
+});

package/tests/naming.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, it } from 'vitest';
+import {
+    CSHARP_KEYWORDS,
+    deriveCSharpFileBase,
+    escapeCSharpIdentifier,
+    escapeXml,
+    quoteCSharpString,
+    safeMemberName,
+    sanitizeCSharpTypeName,
+    toCSharpEnumMemberName,
+    toCSharpParameterName,
+    toCSharpPropertyName,
+    toCSharpTypeName,
+    xmlDocLines,
+} from '../src/naming.js';
+
+describe('escapeCSharpIdentifier', () => {
+    it('prefixes a reserved keyword with @', () => {
+        expect(escapeCSharpIdentifier('params')).toBe('@params');
+        expect(escapeCSharpIdentifier('event')).toBe('@event');
+        expect(escapeCSharpIdentifier('string')).toBe('@string');
+    });
+
+    it('leaves a contextual keyword alone, since it is a legal identifier', () => {
+        for (const name of ['record', 'required', 'init', 'value', 'var', 'async', 'await', 'yield', 'when']) {
+            expect(CSHARP_KEYWORDS.has(name)).toBe(false);
+            expect(escapeCSharpIdentifier(name)).toBe(name);
+        }
+    });
+});
+
+describe('toCSharpPropertyName', () => {
+    it('PascalCases across separators and camelCase boundaries', () => {
+        expect(toCSharpPropertyName('x-request-id')).toBe('XRequestId');
+        expect(toCSharpPropertyName('created_at')).toBe('CreatedAt');
+        expect(toCSharpPropertyName('createdAt')).toBe('CreatedAt');
+        expect(toCSharpPropertyName('myHTTPClient')).toBe('MyHttpClient');
+    });
+
+    it('prefixes a leading digit, which C# identifiers cannot start with', () => {
+        expect(toCSharpPropertyName('2fa')).toBe('_2fa');
+    });
+
+    it('never needs keyword escaping, because every C# keyword is lowercase', () => {
+        expect(toCSharpPropertyName('params')).toBe('Params');
+        expect(toCSharpPropertyName('class')).toBe('Class');
+    });
+});
+
+describe('toCSharpParameterName', () => {
+    it('camelCases a hyphenated path placeholder', () => {
+        expect(toCSharpParameterName('invoice-id')).toBe('invoiceId');
+        expect(toCSharpParameterName('paymentId')).toBe('paymentId');
+    });
+
+    it('escapes a name that lands on a keyword, which camelCase regularly does', () => {
+        expect(toCSharpParameterName('event')).toBe('@event');
+        expect(toCSharpParameterName('params')).toBe('@params');
+    });
+});
+
+describe('safeMemberName', () => {
+    it('renames a member that matches its enclosing type, which C# rejects', () => {
+        expect(safeMemberName('Invoice', 'Invoice')).toBe('InvoiceValue');
+        expect(safeMemberName('Id', 'Invoice')).toBe('Id');
+    });
+
+    it('renames a member a record already synthesizes', () => {
+        expect(safeMemberName('Equals', 'Payment')).toBe('EqualsValue');
+        expect(safeMemberName('ToString', 'Payment')).toBe('ToStringValue');
+        expect(safeMemberName('EqualityContract', 'Payment')).toBe('EqualityContractValue');
+    });
+});
+
+describe('toCSharpTypeName and sanitizeCSharpTypeName', () => {
+    it('PascalCases a source name', () => {
+        expect(toCSharpTypeName('payment-method')).toBe('PaymentMethod');
+        expect(toCSharpTypeName('billing')).toBe('Billing');
+    });
+
+    it('sanitizes an already-composed name without re-casing it', () => {
+        expect(sanitizeCSharpTypeName('MV')).toBe('MV');
+        expect(toCSharpTypeName('MV')).toBe('Mv');
+        expect(sanitizeCSharpTypeName('Get-Payment200')).toBe('GetPayment200');
+    });
+});
+
+describe('toCSharpEnumMemberName', () => {
+    it('PascalCases the wire value, which travels separately', () => {
+        expect(toCSharpEnumMemberName('in-progress')).toBe('InProgress');
+        expect(toCSharpEnumMemberName('pending')).toBe('Pending');
+        expect(toCSharpEnumMemberName('2fa')).toBe('_2fa');
+    });
+});
+
+describe('deriveCSharpFileBase', () => {
+    it('takes the PascalCase base of a .ck path', () => {
+        expect(deriveCSharpFileBase('contracts/ledger.categories.ck')).toBe('LedgerCategories');
+        expect(deriveCSharpFileBase('contracts/billing.op.ck')).toBe('Billing');
+    });
+});
+
+describe('xmlDocLines', () => {
+    it('renders a single line inline and multiple lines as a block', () => {
+        expect(xmlDocLines('A payment', '    ')).toEqual(['    /// <summary>A payment</summary>']);
+        expect(xmlDocLines('One\nTwo', '')).toEqual(['/// <summary>', '/// One', '/// Two', '/// </summary>']);
+    });
+
+    it('escapes XML, since a malformed doc comment is a warning and the build treats it as an error', () => {
+        expect(xmlDocLines('a < b && c > d', '')).toEqual(['/// <summary>a &lt; b &amp;&amp; c &gt; d</summary>']);
+        expect(escapeXml('<T>')).toBe('&lt;T&gt;');
+    });
+
+    it('takes the tag name, so a thrown status can be documented as an exception', () => {
+        expect(xmlDocLines('On 404.', '    ', 'remarks')).toEqual(['    /// <remarks>On 404.</remarks>']);
+    });
+
+    it('returns nothing for empty text, so callers can splat unconditionally', () => {
+        expect(xmlDocLines('', '')).toEqual([]);
+    });
+});
+
+describe('quoteCSharpString', () => {
+    it('escapes the characters that would end or break the literal', () => {
+        expect(quoteCSharpString('a"b')).toBe('"a\\"b"');
+        expect(quoteCSharpString('a\\b')).toBe('"a\\\\b"');
+        expect(quoteCSharpString('a\nb')).toBe('"a\\nb"');
+    });
+
+    it('leaves $ alone, since no generated literal built from contract text is interpolated', () => {
+        expect(quoteCSharpString('a${b}')).toBe('"a${b}"');
+    });
+});

package/tests/runtime.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from 'vitest';
+import { generateRuntimeCs } from '../src/runtime.js';
+import { generateConvertersCs } from '../src/runtime-converters.js';
+import { generateSdkCs } from '../src/codegen-sdk.js';
+
+describe('generateRuntimeCs', () => {
+    const out = generateRuntimeCs('Acme.Sdk');
+
+    it('declares the runtime namespace and the generated-file header', () => {
+        expect(out).toContain('namespace Acme.Sdk.Runtime;');
+        expect(out.startsWith('// <auto-generated/>')).toBe(true);
+        // `<auto-generated/>` turns the nullable context off, so it has to be turned back on.
+        expect(out).toContain('#nullable enable');
+    });
+
+    it('exposes the surface generated clients are written against', () => {
+        expect(out).toContain('public sealed class SdkHttp : IDisposable');
+        expect(out).toContain('public async Task<SdkResponse> ExecuteAsync(');
+        expect(out).toContain('public T ReadJson<T>(SdkResponse response)');
+        expect(out).toContain('public string RequireHeader(SdkResponse response, string name)');
+        expect(out).toContain('public string Path(params string[] segments)');
+        expect(out).toContain('public string Segment<T>(T value)');
+        expect(out).toContain('public IEnumerable<KeyValuePair<string, string>> Params<T>(T value)');
+    });
+
+    it('offers a content factory per request body kind', () => {
+        expect(out).toContain('public HttpContent JsonContent<T>(T value, string mediaType)');
+        expect(out).toContain('public HttpContent FormContent<T>(T value)');
+        expect(out).toContain('public HttpContent MultipartContent(IEnumerable<SdkPart> parts)');
+        expect(out).toContain('public HttpContent TextContent(string value, string mediaType)');
+        expect(out).toContain('public HttpContent BinaryContent(byte[] value, string mediaType)');
+    });
+
+    it('derives the error from HttpRequestException, so callers of the base type still catch it', () => {
+        expect(out).toContain('public class SdkException : HttpRequestException');
+        expect(out).toContain('public T? TryReadBody<T>(JsonSerializerOptions? options = null)');
+    });
+
+    it('throws only for a status outside 2xx that the operation did not declare', () => {
+        expect(out).toContain('if ((status < 200 || status > 299) && (expectStatuses is null || !expectStatuses.Contains(status)))');
+    });
+
+    it('reads the body eagerly, which is what lets a method switch on status and then decode', () => {
+        expect(out).toContain('HttpCompletionOption.ResponseContentRead');
+        expect(out).toContain('ReadAsByteArrayAsync');
+    });
+
+    it('strips content-type parameters, so a charset does not defeat a mime comparison', () => {
+        expect(out).toContain('Message.Content.Headers.ContentType?.MediaType');
+    });
+
+    it('disposes a client it created and leaves a caller-supplied one alone', () => {
+        expect(out).toContain('_ownsClient = options.HttpClient is null;');
+        expect(out).toContain('if (_ownsClient) Client.Dispose();');
+    });
+});
+
+describe('generateConvertersCs', () => {
+    const out = generateConvertersCs('Acme.Sdk');
+
+    it('registers exactly the scalar converters an attribute cannot carry', () => {
+        expect(out).toContain('public static readonly JsonSerializerOptions Options = CreateOptions();');
+        expect(out).toContain('options.Converters.Add(new BigIntegerConverter());');
+        expect(out).toContain('options.Converters.Add(new DecimalStringConverter());');
+        expect(out).toContain('options.Converters.Add(new IsoTimeSpanConverter());');
+    });
+
+    it('writes a decimal as a quoted string and refuses to read an unquoted number', () => {
+        expect(out).toContain('public sealed class DecimalStringConverter : JsonConverter<decimal>');
+        expect(out).toContain('throw new JsonException($"Expected a quoted decimal string, got {reader.TokenType}.");');
+        expect(out).toContain('writer.WriteStringValue(value.ToString(CultureInfo.InvariantCulture));');
+    });
+
+    it('reads the bigint forms every other ContractKit SDK writes', () => {
+        expect(out).toContain("BigInteger.Parse(text.TrimEnd('n'), NumberStyles.Integer, CultureInfo.InvariantCulture)");
+        expect(out).toContain('reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan');
+    });
+
+    it('carries a duration as ISO 8601 rather than the BCL default', () => {
+        expect(out).toContain('XmlConvert.ToTimeSpan(text)');
+        expect(out).toContain('writer.WriteStringValue(XmlConvert.ToString(value));');
+    });
+});
+
+describe('generateSdkCs', () => {
+    it('shares one SdkHttp across every client, so the SDK keeps one connection pool', () => {
+        const out = generateSdkCs('Acme.Sdk', 'AcmeSdk', [
+            { className: 'BillingClient', propertyName: 'Billing' },
+            { className: 'InvoicesClient', propertyName: 'Invoices' },
+        ]);
+        expect(out).toContain('public sealed class AcmeSdk : IDisposable');
+        expect(out).toContain('Http = new SdkHttp(options);');
+        expect(out).toContain('Billing = new BillingClient(Http);');
+        expect(out).toContain('Invoices = new InvoicesClient(Http);');
+        expect(out).toContain('public BillingClient Billing { get; }');
+        expect(out).toContain('using Acme.Sdk.Clients;');
+    });
+
+    it('compiles with no clients at all, and then imports no client namespace', () => {
+        const out = generateSdkCs('Acme.Sdk', 'Sdk', []);
+        expect(out).toContain('public sealed class Sdk : IDisposable');
+        expect(out).not.toContain('using Acme.Sdk.Clients;');
+    });
+});

package/tests/scaffold.test.ts

@@ -0,0 +1,28 @@
+import { describe, expect, it } from 'vitest';
+import { SCAFFOLD_VERSIONS, generateCsproj } from '../src/scaffold.js';
+
+describe('generateCsproj', () => {
+    it('targets the pinned framework', () => {
+        expect(generateCsproj('Acme.Sdk', 'AcmeSdk')).toContain(`<TargetFramework>${SCAFFOLD_VERSIONS.targetFramework}</TargetFramework>`);
+    });
+
+    it('takes the namespace and assembly name from config', () => {
+        const out = generateCsproj('Acme.Sdk', 'AcmeSdk');
+        expect(out).toContain('<RootNamespace>Acme.Sdk</RootNamespace>');
+        expect(out).toContain('<AssemblyName>AcmeSdk</AssemblyName>');
+    });
+
+    it('enables nullable and disables implicit usings, which generated files declare for themselves', () => {
+        const out = generateCsproj('Acme.Sdk', 'AcmeSdk');
+        expect(out).toContain('<Nullable>enable</Nullable>');
+        expect(out).toContain('<ImplicitUsings>disable</ImplicitUsings>');
+    });
+
+    it('declares no package reference, so the SDK restores with no NuGet feed reachable', () => {
+        expect(generateCsproj('Acme.Sdk', 'AcmeSdk')).not.toContain('PackageReference');
+    });
+
+    it('says it is never regenerated, since the file is the user’s after the first run', () => {
+        expect(generateCsproj('Acme.Sdk', 'AcmeSdk')).toContain('never regenerated');
+    });
+});

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+    "extends": "@repo/config-typescript/base.json",
+    "compilerOptions": {
+        "outDir": "./dist",
+        "rootDir": "./src"
+    },
+    "include": ["src/**/*"],
+    "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,14 @@
+import { defineProject } from 'vitest/config';
+import swc from 'unplugin-swc';
+
+export default defineProject({
+    test: {
+        globals: true,
+        include: ['./tests/**/*.test.ts'],
+        environment: 'node',
+        testTimeout: 50000,
+        hookTimeout: 30000,
+        fileParallelism: true,
+    },
+    plugins: [swc.vite()],
+});