init

GLM5Analysis/TestScaffolds/ServiceTestScaffold.cs

@@ -0,0 +1,158 @@
+using System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using NSubstitute;
+
+namespace YourNamespace.Tests
+{
+    [TestFixture]
+    public class ServiceShould
+    {
+        private IServiceDependency _dependency;
+
+        [SetUp]
+        public void Setup()
+        {
+            _dependency = Substitute.For<IServiceDependency>();
+        }
+
+        [Test]
+        public async Task ReturnResult_WhenOperationCompletes()
+        {
+            var expected = new ServiceResult { Value = 42 };
+            _dependency.GetDataAsync().Returns(Task.FromResult(expected));
+            var sut = CreateSut();
+
+            var result = await sut.PerformOperationAsync();
+
+            Assert.That(result, Is.Not.Null);
+            Assert.That(result.Value, Is.EqualTo(42));
+        }
+
+        [Test]
+        public async Task CallDependency_WhenOperationIsPerformed()
+        {
+            var sut = CreateSut();
+
+            await sut.PerformOperationAsync();
+
+            await _dependency.Received(1).GetDataAsync();
+        }
+
+        [Test]
+        public async Task InvokeCallback_WhenOperationCompletes()
+        {
+            var callbackInvoked = false;
+            var sut = CreateSut();
+            sut.OnCompleted += () => callbackInvoked = true;
+
+            await sut.PerformOperationAsync();
+
+            Assert.That(callbackInvoked, Is.True);
+        }
+
+        [Test]
+        public async Task InvokeCallbackWithError_WhenOperationFails()
+        {
+            _dependency.GetDataAsync().Returns(Task.FromException<ServiceResult>(new System.Exception("Test error")));
+            var errorCallbackInvoked = false;
+            var sut = CreateSut();
+            sut.OnError += (ex) => errorCallbackInvoked = true;
+
+            try
+            {
+                await sut.PerformOperationAsync();
+            }
+            catch
+            {
+            }
+
+            Assert.That(errorCallbackInvoked, Is.True);
+        }
+
+        [Test]
+        public void ThrowException_WhenNotInitialized()
+        {
+            var sut = new TestService(null);
+
+            Assert.ThrowsAsync<System.InvalidOperationException>(() => sut.PerformOperationAsync());
+        }
+
+        [Test]
+        public async Task CancelOperation_WhenCancellationTokenIsCancelled()
+        {
+            var cts = new CancellationTokenSource();
+            cts.Cancel();
+            var sut = CreateSut();
+
+            Assert.ThrowsAsync<OperationCanceledException>(() => sut.PerformOperationAsync(cts.Token));
+        }
+
+        [Test]
+        public async Task SupportMultipleConcurrentOperations()
+        {
+            var sut = CreateSut();
+
+            var tasks = Enumerable.Range(0, 5)
+                .Select(_ => sut.PerformOperationAsync())
+                .ToArray();
+
+            var results = await Task.WhenAll(tasks);
+
+            Assert.That(results.Length, Is.EqualTo(5));
+            Assert.That(results.All(r => r != null), Is.True);
+        }
+
+        private TestService CreateSut()
+        {
+            return new TestService(_dependency);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+        }
+    }
+
+    public interface IServiceDependency
+    {
+        Task<ServiceResult> GetDataAsync();
+    }
+
+    public class ServiceResult
+    {
+        public int Value { get; set; }
+    }
+
+    public class TestService
+    {
+        private readonly IServiceDependency _dependency;
+        public event Action OnCompleted;
+        public event Action<System.Exception> OnError;
+
+        public TestService(IServiceDependency dependency)
+        {
+            _dependency = dependency;
+        }
+
+        public async Task<ServiceResult> PerformOperationAsync(CancellationToken cancellationToken = default)
+        {
+            if (_dependency == null)
+                throw new System.InvalidOperationException("Service not initialized");
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            try
+            {
+                var result = await _dependency.GetDataAsync();
+                OnCompleted?.Invoke();
+                return result;
+            }
+            catch (System.Exception ex)
+            {
+                OnError?.Invoke(ex);
+                throw;
+            }
+        }
+    }
+}