Extend numeric integration tests to long, short, decimal, float, double (#26)

Adds entity/controller/test classes for every (constraint × underlying
type) combo beyond int, so the end-to-end ASP.NET Core + EF Core pipeline
is exercised for Positive/NonNegative/Negative/NonPositive across all
supported numeric underlying types. Test suite grows from 101 to 501
tests, all passing against both SQL Server and PostgreSQL.

Decimal test values stay within two fractional digits so they round-trip
through EF Core's default SQL Server decimal(18,2) mapping.

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: KaliCZ

src/StrongTypes.Api.IntegrationTests/Tests/NegativeDecimalEntityTests.cs

@@ -0,0 +1,19 @@
+using StrongTypes.Api.Entities;
+using StrongTypes.Api.IntegrationTests.Infrastructure;
+using Xunit;
+
+namespace StrongTypes.Api.IntegrationTests.Tests;
+
+[Collection(IntegrationTestCollection.Name)]
+public sealed class NegativeDecimalEntityTests(TestWebApplicationFactory factory)
+    : EntityTests<NegativeDecimalEntityTests, NegativeDecimalEntity, Negative<decimal>, Negative<decimal>?, decimal>(factory),
+      IEntityTestData<decimal>
+{
+    protected override string RoutePrefix => "negative-decimal-entities";
+    protected override Negative<decimal> Create(decimal raw) => Negative<decimal>.Create(raw);
+    protected override decimal FirstValid => -5m;
+    protected override decimal UpdatedValid => -100m;
+
+    public static TheoryData<decimal> ValidInputs => new() { -5m, -42m, -10m, -1m, -1.5m, -0.01m };
+    public static TheoryData<decimal> InvalidInputs => new() { 0m, 1m, 100m, 1.5m };
+}

src/StrongTypes.Api.IntegrationTests/Tests/NegativeDoubleEntityTests.cs

@@ -0,0 +1,19 @@
+using StrongTypes.Api.Entities;
+using StrongTypes.Api.IntegrationTests.Infrastructure;
+using Xunit;
+
+namespace StrongTypes.Api.IntegrationTests.Tests;
+
+[Collection(IntegrationTestCollection.Name)]
+public sealed class NegativeDoubleEntityTests(TestWebApplicationFactory factory)
+    : EntityTests<NegativeDoubleEntityTests, NegativeDoubleEntity, Negative<double>, Negative<double>?, double>(factory),
+      IEntityTestData<double>
+{
+    protected override string RoutePrefix => "negative-double-entities";
+    protected override Negative<double> Create(double raw) => Negative<double>.Create(raw);
+    protected override double FirstValid => -5d;
+    protected override double UpdatedValid => -100d;
+
+    public static TheoryData<double> ValidInputs => new() { -5d, -42d, -10d, -1d, -1.5d, double.MinValue };
+    public static TheoryData<double> InvalidInputs => new() { 0d, 1d, 100d, 1.5d, double.MaxValue };
+}

src/StrongTypes.Api.IntegrationTests/Tests/NegativeFloatEntityTests.cs

@@ -0,0 +1,19 @@
+using StrongTypes.Api.Entities;
+using StrongTypes.Api.IntegrationTests.Infrastructure;
+using Xunit;
+
+namespace StrongTypes.Api.IntegrationTests.Tests;
+
+[Collection(IntegrationTestCollection.Name)]
+public sealed class NegativeFloatEntityTests(TestWebApplicationFactory factory)
+    : EntityTests<NegativeFloatEntityTests, NegativeFloatEntity, Negative<float>, Negative<float>?, float>(factory),
+      IEntityTestData<float>
+{
+    protected override string RoutePrefix => "negative-float-entities";
+    protected override Negative<float> Create(float raw) => Negative<float>.Create(raw);
+    protected override float FirstValid => -5f;
+    protected override float UpdatedValid => -100f;
+
+    public static TheoryData<float> ValidInputs => new() { -5f, -42f, -10f, -1f, -1.5f, float.MinValue };
+    public static TheoryData<float> InvalidInputs => new() { 0f, 1f, 100f, 1.5f, float.MaxValue };
+}

src/StrongTypes.Api.IntegrationTests/Tests/NegativeLongEntityTests.cs

@@ -0,0 +1,19 @@
+using StrongTypes.Api.Entities;
+using StrongTypes.Api.IntegrationTests.Infrastructure;
+using Xunit;
+
+namespace StrongTypes.Api.IntegrationTests.Tests;
+
+[Collection(IntegrationTestCollection.Name)]
+public sealed class NegativeLongEntityTests(TestWebApplicationFactory factory)
+    : EntityTests<NegativeLongEntityTests, NegativeLongEntity, Negative<long>, Negative<long>?, long>(factory),
+      IEntityTestData<long>
+{
+    protected override string RoutePrefix => "negative-long-entities";
+    protected override Negative<long> Create(long raw) => Negative<long>.Create(raw);
+    protected override long FirstValid => -5L;
+    protected override long UpdatedValid => -100L;
+
+    public static TheoryData<long> ValidInputs => new() { -5L, -42L, -10L, -1L, long.MinValue };
+    public static TheoryData<long> InvalidInputs => new() { 0L, 1L, 100L, long.MaxValue };
+}

src/StrongTypes.Api.IntegrationTests/Tests/NegativeShortEntityTests.cs

@@ -0,0 +1,19 @@
+using StrongTypes.Api.Entities;
+using StrongTypes.Api.IntegrationTests.Infrastructure;
+using Xunit;
+
+namespace StrongTypes.Api.IntegrationTests.Tests;
+
+[Collection(IntegrationTestCollection.Name)]
+public sealed class NegativeShortEntityTests(TestWebApplicationFactory factory)
+    : EntityTests<NegativeShortEntityTests, NegativeShortEntity, Negative<short>, Negative<short>?, short>(factory),
+      IEntityTestData<short>
+{
+    protected override string RoutePrefix => "negative-short-entities";
+    protected override Negative<short> Create(short raw) => Negative<short>.Create(raw);
+    protected override short FirstValid => -5;
+    protected override short UpdatedValid => -100;
+
+    public static TheoryData<short> ValidInputs => new() { (short)-5, (short)-42, (short)-10, (short)-1, short.MinValue };
+    public static TheoryData<short> InvalidInputs => new() { (short)0, (short)1, (short)100, short.MaxValue };
+}

src/StrongTypes.Api.IntegrationTests/Tests/NonNegativeDecimalEntityTests.cs

@@ -0,0 +1,19 @@
+using StrongTypes.Api.Entities;
+using StrongTypes.Api.IntegrationTests.Infrastructure;
+using Xunit;
+
+namespace StrongTypes.Api.IntegrationTests.Tests;
+
+[Collection(IntegrationTestCollection.Name)]
+public sealed class NonNegativeDecimalEntityTests(TestWebApplicationFactory factory)
+    : EntityTests<NonNegativeDecimalEntityTests, NonNegativeDecimalEntity, NonNegative<decimal>, NonNegative<decimal>?, decimal>(factory),
+      IEntityTestData<decimal>
+{
+    protected override string RoutePrefix => "non-negative-decimal-entities";
+    protected override NonNegative<decimal> Create(decimal raw) => NonNegative<decimal>.Create(raw);
+    protected override decimal FirstValid => 0m;
+    protected override decimal UpdatedValid => 100m;
+
+    public static TheoryData<decimal> ValidInputs => new() { 0m, 5m, 42m, 10m, 1.5m, 0.01m };
+    public static TheoryData<decimal> InvalidInputs => new() { -1m, -100m, -1.5m };
+}

src/StrongTypes.Api.IntegrationTests/Tests/NonNegativeDoubleEntityTests.cs

@@ -0,0 +1,19 @@
+using StrongTypes.Api.Entities;
+using StrongTypes.Api.IntegrationTests.Infrastructure;
+using Xunit;
+
+namespace StrongTypes.Api.IntegrationTests.Tests;
+
+[Collection(IntegrationTestCollection.Name)]
+public sealed class NonNegativeDoubleEntityTests(TestWebApplicationFactory factory)
+    : EntityTests<NonNegativeDoubleEntityTests, NonNegativeDoubleEntity, NonNegative<double>, NonNegative<double>?, double>(factory),
+      IEntityTestData<double>
+{
+    protected override string RoutePrefix => "non-negative-double-entities";
+    protected override NonNegative<double> Create(double raw) => NonNegative<double>.Create(raw);
+    protected override double FirstValid => 0d;
+    protected override double UpdatedValid => 100d;
+
+    public static TheoryData<double> ValidInputs => new() { 0d, 5d, 42d, 10d, 1.5d, double.MaxValue };
+    public static TheoryData<double> InvalidInputs => new() { -1d, -100d, -1.5d, double.MinValue };
+}

src/StrongTypes.Api.IntegrationTests/Tests/NonNegativeFloatEntityTests.cs

@@ -0,0 +1,19 @@
+using StrongTypes.Api.Entities;
+using StrongTypes.Api.IntegrationTests.Infrastructure;
+using Xunit;
+
+namespace StrongTypes.Api.IntegrationTests.Tests;
+
+[Collection(IntegrationTestCollection.Name)]
+public sealed class NonNegativeFloatEntityTests(TestWebApplicationFactory factory)
+    : EntityTests<NonNegativeFloatEntityTests, NonNegativeFloatEntity, NonNegative<float>, NonNegative<float>?, float>(factory),
+      IEntityTestData<float>
+{
+    protected override string RoutePrefix => "non-negative-float-entities";
+    protected override NonNegative<float> Create(float raw) => NonNegative<float>.Create(raw);
+    protected override float FirstValid => 0f;
+    protected override float UpdatedValid => 100f;
+
+    public static TheoryData<float> ValidInputs => new() { 0f, 5f, 42f, 10f, 1.5f, float.MaxValue };
+    public static TheoryData<float> InvalidInputs => new() { -1f, -100f, -1.5f, float.MinValue };
+}

src/StrongTypes.Api.IntegrationTests/Tests/NonNegativeLongEntityTests.cs

@@ -0,0 +1,19 @@
+using StrongTypes.Api.Entities;
+using StrongTypes.Api.IntegrationTests.Infrastructure;
+using Xunit;
+
+namespace StrongTypes.Api.IntegrationTests.Tests;
+
+[Collection(IntegrationTestCollection.Name)]
+public sealed class NonNegativeLongEntityTests(TestWebApplicationFactory factory)
+    : EntityTests<NonNegativeLongEntityTests, NonNegativeLongEntity, NonNegative<long>, NonNegative<long>?, long>(factory),
+      IEntityTestData<long>
+{
+    protected override string RoutePrefix => "non-negative-long-entities";
+    protected override NonNegative<long> Create(long raw) => NonNegative<long>.Create(raw);
+    protected override long FirstValid => 0L;
+    protected override long UpdatedValid => 100L;
+
+    public static TheoryData<long> ValidInputs => new() { 0L, 5L, 42L, 10L, long.MaxValue };
+    public static TheoryData<long> InvalidInputs => new() { -1L, -100L, long.MinValue };
+}

src/StrongTypes.Api.IntegrationTests/Tests/NonNegativeShortEntityTests.cs

@@ -0,0 +1,19 @@
+using StrongTypes.Api.Entities;
+using StrongTypes.Api.IntegrationTests.Infrastructure;
+using Xunit;
+
+namespace StrongTypes.Api.IntegrationTests.Tests;
+
+[Collection(IntegrationTestCollection.Name)]
+public sealed class NonNegativeShortEntityTests(TestWebApplicationFactory factory)
+    : EntityTests<NonNegativeShortEntityTests, NonNegativeShortEntity, NonNegative<short>, NonNegative<short>?, short>(factory),
+      IEntityTestData<short>
+{
+    protected override string RoutePrefix => "non-negative-short-entities";
+    protected override NonNegative<short> Create(short raw) => NonNegative<short>.Create(raw);
+    protected override short FirstValid => 0;
+    protected override short UpdatedValid => 100;
+
+    public static TheoryData<short> ValidInputs => new() { (short)0, (short)5, (short)42, (short)10, short.MaxValue };
+    public static TheoryData<short> InvalidInputs => new() { (short)-1, (short)-100, short.MinValue };
+}