@contractkit/plugin-csharp 0.1.5 → 0.2.0

package/tests/index.test.ts

@@ -64,6 +64,25 @@ describe('assertValidConfig', () => {
         expect(() => assertValidConfig({ scaffold: 'yes' as never })).toThrow(/scaffold must be a boolean/);
         expect(() => assertValidConfig({ includeInternal: 1 as never })).toThrow(/includeInternal must be a boolean/);
     });
+
+    it('accepts the frameworks the scaffold knows, in either order', () => {
+        expect(() => assertValidConfig({ targetFrameworks: ['net10.0'] })).not.toThrow();
+        expect(() => assertValidConfig({ targetFrameworks: ['netstandard2.0'] })).not.toThrow();
+        expect(() => assertValidConfig({ targetFrameworks: ['netstandard2.0', 'net10.0'] })).not.toThrow();
+    });
+
+    it('rejects a targetFrameworks list that is empty, unknown, or repeated', () => {
+        expect(() => assertValidConfig({ targetFrameworks: [] })).toThrow(/must be a non-empty array/);
+        expect(() => assertValidConfig({ targetFrameworks: 'net10.0' as never })).toThrow(/must be a non-empty array/);
+        expect(() => assertValidConfig({ targetFrameworks: ['net48' as never] })).toThrow(/is not supported/);
+        expect(() => assertValidConfig({ targetFrameworks: ['net10.0', 'net10.0'] })).toThrow(/lists 'net10.0' twice/);
+    });
+
+    it('accepts either date mapping and rejects anything else', () => {
+        expect(() => assertValidConfig({ dateTypes: 'dateonly' })).not.toThrow();
+        expect(() => assertValidConfig({ dateTypes: 'datetime' })).not.toThrow();
+        expect(() => assertValidConfig({ dateTypes: 'DateTime' as never })).toThrow(/dateTypes "DateTime" is not supported/);
+    });
 });
 
 describe('generateTargets', () => {
@@ -115,6 +134,30 @@ describe('generateTargets', () => {
         expect(on.ifAbsent).toEqual(['cssdk/AcmeSdk.csproj']);
     });
 
+    it('emits the polyfills only for a build that includes netstandard2.0', async () => {
+        const off = makeCtx();
+        await createCSharpSdkPlugin({ baseDir: 'cssdk' }, ROOT_DIR).generateTargets!(INPUTS, off);
+        expect(off.emitted.has('cssdk/Runtime/Polyfills.cs')).toBe(false);
+
+        const on = makeCtx();
+        await createCSharpSdkPlugin({ baseDir: 'cssdk', namespace: 'Acme.Sdk', targetFrameworks: ['netstandard2.0', 'net10.0'] }, ROOT_DIR)
+            .generateTargets!(INPUTS, on);
+        const polyfills = on.emitted.get('cssdk/Runtime/Polyfills.cs');
+        expect(polyfills).toContain('namespace Acme.Sdk.Runtime');
+        expect(polyfills).toContain('public readonly struct DateOnly');
+        // The whole file is conditional, so the net10.0 leg of the same build compiles none of it.
+        expect(polyfills?.includes('#if NETSTANDARD2_0')).toBe(true);
+    });
+
+    it('multi-targets the scaffolded project file when the config asks for netstandard2.0', async () => {
+        const ctx = makeCtx();
+        await createCSharpSdkPlugin(
+            { baseDir: 'cssdk', sdkName: 'AcmeSdk', scaffold: true, targetFrameworks: ['netstandard2.0', 'net10.0'] },
+            ROOT_DIR,
+        ).generateTargets!(INPUTS, ctx);
+        expect(ctx.emitted.get('cssdk/AcmeSdk.csproj')).toContain('<TargetFrameworks>netstandard2.0;net10.0</TargetFrameworks>');
+    });
+
     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);

package/tests/runtime.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
 import { generateRuntimeCs } from '../src/runtime.js';
 import { generateConvertersCs } from '../src/runtime-converters.js';
+import { generatePolyfillsCs } from '../src/runtime-polyfills.js';
 import { generateSdkCs } from '../src/codegen-sdk.js';
 
 describe('generateRuntimeCs', () => {
@@ -23,6 +24,10 @@ describe('generateRuntimeCs', () => {
         expect(out).toContain('public IEnumerable<KeyValuePair<string, string>> Params<T>(T value)');
     });
 
+    it('carries a PATCH verb of its own, the one HttpMethod does not spell on every framework', () => {
+        expect(out).toContain('public static readonly HttpMethod Patch = new HttpMethod("PATCH");');
+    });
+
     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)');
@@ -53,6 +58,55 @@ describe('generateRuntimeCs', () => {
         expect(out).toContain('_ownsClient = options.HttpClient is null;');
         expect(out).toContain('if (_ownsClient) Client.Dispose();');
     });
+
+    it('takes the older spelling of the two members netstandard2.0 declares differently', () => {
+        // HttpRequestException gained a status-carrying constructor in .NET 5, and
+        // ReadAsByteArrayAsync a cancellable overload; both have a fallback on the old framework.
+        expect(out).toContain('        : base(message ?? $"Request failed with status {status}")\n#else');
+        expect(out).toContain('var bytes = await message.Content.ReadAsByteArrayAsync().ConfigureAwait(false);');
+        // The status conversion has no caller on the old framework, so it is not compiled there.
+        expect(out).toContain('#if !NETSTANDARD2_0\n    private static HttpStatusCode? ToStatusCode(int status)');
+    });
+});
+
+describe('generatePolyfillsCs', () => {
+    const out = generatePolyfillsCs('Acme.Sdk');
+
+    it('compiles on netstandard2.0 alone, so a project with no old leg carries nothing', () => {
+        expect(out).toContain('#if NETSTANDARD2_0');
+        expect(out.trimEnd().endsWith('#endif')).toBe(true);
+    });
+
+    it('declares the attributes the compiler looks for before it accepts init and required', () => {
+        expect(out).toContain('namespace System.Runtime.CompilerServices');
+        expect(out).toContain('internal static class IsExternalInit');
+        expect(out).toContain('internal sealed class RequiredMemberAttribute : Attribute');
+        expect(out).toContain('internal sealed class CompilerFeatureRequiredAttribute : Attribute');
+        expect(out).toContain('internal sealed class SetsRequiredMembersAttribute : Attribute');
+    });
+
+    it('declares the date and time types in the SDK’s own namespace, not in System', () => {
+        expect(out).toContain('namespace Acme.Sdk.Runtime');
+        expect(out).toContain('public readonly struct DateOnly : IEquatable<DateOnly>, IComparable<DateOnly>, IComparable');
+        expect(out).toContain('public readonly struct TimeOnly : IEquatable<TimeOnly>, IComparable<TimeOnly>, IComparable');
+        expect(out).not.toContain('namespace System;');
+    });
+
+    it('writes the same wire form the framework types do, so one service reads either leg', () => {
+        expect(out).toContain(`_value.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture)`);
+        expect(out).toContain(`_value.ToString("hh':'mm':'ss", CultureInfo.InvariantCulture)`);
+        // Seven digits, not the trimmed form: System.Text.Json writes 09:30:15.2500000.
+        expect(out).toContain(`_value.ToString("hh':'mm':'ss'.'fffffff", CultureInfo.InvariantCulture)`);
+        // Reading stays lenient, so a body written by a trimming client still parses.
+        expect(out).toContain(`{ "HH:mm:ss.FFFFFFF", "HH:mm" }`);
+    });
+
+    it('converts to the types a XAML picker binds to', () => {
+        expect(out).toContain('public DateTime ToDateTime()');
+        expect(out).toContain('public TimeSpan ToTimeSpan()');
+        expect(out).toContain('public static TimeOnly FromTimeSpan(TimeSpan value)');
+        expect(out).toContain('public static DateOnly FromDateTime(DateTime value)');
+    });
 });
 
 describe('generateConvertersCs', () => {
@@ -73,13 +127,41 @@ describe('generateConvertersCs', () => {
 
     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');
+        // Both branches copy to an array: the span overload of GetString is not on every framework.
+        expect(out).toContain('reader.HasValueSequence ? reader.ValueSequence.ToArray() : reader.ValueSpan.ToArray()');
     });
 
     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));');
     });
+
+    it('registers a date and time converter only where those types are the SDK’s own', () => {
+        expect(out).toContain('#if NETSTANDARD2_0');
+        expect(out).toContain('options.Converters.Add(new DateOnlyConverter());');
+        expect(out).toContain('options.Converters.Add(new TimeOnlyConverter());');
+        expect(out).toContain('public sealed class DateOnlyConverter : JsonConverter<DateOnly>');
+        expect(out).toContain('public sealed class TimeOnlyConverter : JsonConverter<TimeOnly>');
+    });
+
+    describe('under dateTypes: datetime', () => {
+        const dt = generateConvertersCs('Acme.Sdk', 'datetime');
+
+        it('carries a date as the date part of a DateTime, on every framework', () => {
+            expect(dt).toContain('options.Converters.Add(new IsoDateConverter());');
+            expect(dt).toContain('public sealed class IsoDateConverter : JsonConverter<DateTime>');
+            expect(dt).toContain(`writer.WriteStringValue(value.ToString("yyyy-MM-dd", CultureInfo.InvariantCulture));`);
+            // Options-level rather than per-property, which is only safe because `datetime` maps to
+            // DateTimeOffset and so nothing else in a generated model is a DateTime.
+            expect(dt).not.toContain('JsonConverter<DateTimeOffset>');
+        });
+
+        it('drops the DateOnly converter, which no generated type would reach any more', () => {
+            expect(dt).not.toContain('DateOnlyConverter');
+            // TimeOnly is unchanged by the option, so its netstandard2.0 converter stays.
+            expect(dt).toContain('options.Converters.Add(new TimeOnlyConverter());');
+        });
+    });
 });
 
 describe('generateSdkCs', () => {

package/tests/scaffold.test.ts

@@ -25,4 +25,26 @@ describe('generateCsproj', () => {
     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');
     });
+
+    it('keeps the single-framework output identical however the one framework is spelled', () => {
+        expect(generateCsproj('Acme.Sdk', 'AcmeSdk', ['net10.0'])).toBe(generateCsproj('Acme.Sdk', 'AcmeSdk'));
+    });
+
+    it('multi-targets, pins the language version and references System.Text.Json for netstandard2.0', () => {
+        const out = generateCsproj('Acme.Sdk', 'AcmeSdk', ['netstandard2.0', 'net10.0']);
+        expect(out).toContain('<TargetFrameworks>netstandard2.0;net10.0</TargetFrameworks>');
+        expect(out).not.toContain('<TargetFramework>');
+        // Both conditioned on the old framework, so net10.0 keeps its default language version and
+        // its dependency-free restore.
+        expect(out).toContain(`<PropertyGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">`);
+        expect(out).toContain(`<LangVersion>${SCAFFOLD_VERSIONS.netstandardLangVersion}</LangVersion>`);
+        expect(out).toContain(`<ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">`);
+        expect(out).toContain(`<PackageReference Include="System.Text.Json" Version="${SCAFFOLD_VERSIONS.systemTextJson}" />`);
+    });
+
+    it('can target netstandard2.0 on its own', () => {
+        const out = generateCsproj('Acme.Sdk', 'AcmeSdk', ['netstandard2.0']);
+        expect(out).toContain('<TargetFramework>netstandard2.0</TargetFramework>');
+        expect(out).toContain('<PackageReference Include="System.Text.Json"');
+    });
 });