init

GLM5Analysis/TestScaffolds/DatabaseTestScaffold.cs

@@ -0,0 +1,227 @@
+using System.Data;
+using NUnit.Framework;
+using NSubstitute;
+
+namespace YourNamespace.Tests
+{
+    [TestFixture]
+    public class DatabaseShould
+    {
+        private IDbConnection _connection;
+        private IDbTransaction _transaction;
+        private IDbCommand _command;
+
+        [SetUp]
+        public void Setup()
+        {
+            _connection = Substitute.For<IDbConnection>();
+            _transaction = Substitute.For<IDbTransaction>();
+            _command = Substitute.For<IDbCommand>();
+            
+            _connection.BeginTransaction().Returns(_transaction);
+            _connection.CreateCommand().Returns(_command);
+        }
+
+        [Test]
+        public void ExecuteQuery_ReturnExpectedResults()
+        {
+            var reader = Substitute.For<IDataReader>();
+            reader.Read().Returns(true, true, false);
+            reader[0].Returns("Value1", "Value2");
+            _command.ExecuteReader().Returns(reader);
+            var sut = CreateSut();
+
+            var results = sut.ExecuteQuery("SELECT * FROM Table");
+
+            Assert.That(results.Count, Is.EqualTo(2));
+            Assert.That(results[0], Is.EqualTo("Value1"));
+            Assert.That(results[1], Is.EqualTo("Value2"));
+        }
+
+        [Test]
+        public void CommitTransaction_WhenOperationSucceeds()
+        {
+            var sut = CreateSut();
+
+            sut.ExecuteInTransaction(() => { _command.ExecuteNonQuery(); });
+
+            _transaction.Received(1).Commit();
+        }
+
+        [Test]
+        public void RollbackTransaction_WhenOperationFails()
+        {
+            _command.When(c => c.ExecuteNonQuery()).Do(_ => throw new System.Exception("DB Error"));
+            var sut = CreateSut();
+
+            Assert.Throws<System.Exception>(() => sut.ExecuteInTransaction(() => _command.ExecuteNonQuery()));
+
+            _transaction.Received(1).Rollback();
+        }
+
+        [Test]
+        public void UseCorrectParameters_WhenExecutingCommand()
+        {
+            var parameter = Substitute.For<IDbDataParameter>();
+            _command.CreateParameter().Returns(parameter);
+            var sut = CreateSut();
+
+            sut.ExecuteWithParameter("INSERT INTO Table (Col) VALUES (@val)", "@val", "TestValue");
+
+            _command.Received(1).Parameters.Add(Arg.Is<IDbDataParameter>(p => 
+                p.ParameterName == "@val" && (string)p.Value == "TestValue"));
+        }
+
+        [Test]
+        public void ReturnRowCount_WhenExecutingNonQuery()
+        {
+            _command.ExecuteNonQuery().Returns(5);
+            var sut = CreateSut();
+
+            var count = sut.ExecuteNonQuery("DELETE FROM Table");
+
+            Assert.That(count, Is.EqualTo(5));
+        }
+
+        [Test]
+        public void HandleNullValues_InQueryResults()
+        {
+            var reader = Substitute.For<IDataReader>();
+            reader.Read().Returns(true, false);
+            reader.IsDBNull(0).Returns(true);
+            _command.ExecuteReader().Returns(reader);
+            var sut = CreateSut();
+
+            var results = sut.ExecuteQuery("SELECT Col FROM Table");
+
+            Assert.That(results.Count, Is.EqualTo(1));
+            Assert.That(results[0], Is.Null);
+        }
+
+        [Test]
+        public void CloseConnection_AfterOperation()
+        {
+            _connection.State.Returns(ConnectionState.Open);
+            var sut = CreateSut();
+
+            sut.CloseConnection();
+
+            _connection.Received(1).Close();
+        }
+
+        [Test]
+        public void ThrowException_WhenConnectionFails()
+        {
+            _connection.When(c => c.Open()).Do(_ => throw new System.Exception("Connection failed"));
+            var sut = CreateSut();
+
+            Assert.Throws<System.Exception>(() => sut.OpenConnection());
+        }
+
+        [Test]
+        public void ExecuteScalar_ReturnCorrectValue()
+        {
+            _command.ExecuteScalar().Returns(42);
+            var sut = CreateSut();
+
+            var result = sut.ExecuteScalar("SELECT COUNT(*) FROM Table");
+
+            Assert.That(result, Is.EqualTo(42));
+        }
+
+        private DatabaseService CreateSut()
+        {
+            return new DatabaseService(_connection);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            _connection?.Dispose();
+            _command?.Dispose();
+        }
+    }
+
+    public class DatabaseService
+    {
+        private readonly IDbConnection _connection;
+
+        public DatabaseService(IDbConnection connection)
+        {
+            _connection = connection;
+        }
+
+        public void OpenConnection() => _connection.Open();
+
+        public void CloseConnection()
+        {
+            if (_connection.State == ConnectionState.Open)
+                _connection.Close();
+        }
+
+        public List<object> ExecuteQuery(string sql)
+        {
+            var results = new List<object>();
+            using (var command = _connection.CreateCommand())
+            {
+                command.CommandText = sql;
+                using (var reader = command.ExecuteReader())
+                {
+                    while (reader.Read())
+                    {
+                        results.Add(reader.IsDBNull(0) ? null : reader[0]);
+                    }
+                }
+            }
+            return results;
+        }
+
+        public int ExecuteNonQuery(string sql)
+        {
+            using (var command = _connection.CreateCommand())
+            {
+                command.CommandText = sql;
+                return command.ExecuteNonQuery();
+            }
+        }
+
+        public object ExecuteScalar(string sql)
+        {
+            using (var command = _connection.CreateCommand())
+            {
+                command.CommandText = sql;
+                return command.ExecuteScalar();
+            }
+        }
+
+        public void ExecuteInTransaction(Action operation)
+        {
+            using (var transaction = _connection.BeginTransaction())
+            {
+                try
+                {
+                    operation();
+                    transaction.Commit();
+                }
+                catch
+                {
+                    transaction.Rollback();
+                    throw;
+                }
+            }
+        }
+
+        public void ExecuteWithParameter(string sql, string paramName, object value)
+        {
+            using (var command = _connection.CreateCommand())
+            {
+                command.CommandText = sql;
+                var parameter = command.CreateParameter();
+                parameter.ParameterName = paramName;
+                parameter.Value = value;
+                command.Parameters.Add(parameter);
+                command.ExecuteNonQuery();
+            }
+        }
+    }
+}

GLM5Analysis/TestScaffolds/ModuleTestScaffold.cs

@@ -0,0 +1,111 @@
+using NUnit.Framework;
+using NSubstitute;
+using Prism.Modularity;
+using Prism.Ioc;
+using Unity;
+
+namespace YourNamespace.Tests
+{
+    [TestFixture]
+    public class ModuleShould
+    {
+        private IUnityContainer _unityContainer;
+        private IContainerRegistry _containerRegistry;
+        private IContainerProvider _containerProvider;
+
+        [SetUp]
+        public void Setup()
+        {
+            _unityContainer = Substitute.For<IUnityContainer>();
+            _containerRegistry = Substitute.For<IContainerRegistry>();
+            _containerProvider = Substitute.For<IContainerProvider>();
+        }
+
+        [Test]
+        public void RegisterTypes_WhenRegisterTypesIsCalled()
+        {
+            var sut = CreateSut();
+
+            sut.RegisterTypes(_containerRegistry);
+
+            _containerRegistry.Received().Register(Arg.Any<Func<object>>());
+        }
+
+        [Test]
+        public void Initialize_WhenInitializeIsCalled()
+        {
+            var sut = CreateSut();
+
+            sut.Initialize();
+
+            _unityContainer.Received().RegisterType(Arg.Any<System.Type>(), Arg.Any<System.Type>());
+        }
+
+        [Test]
+        public void RegisterViewAndViewModel_AsSingletons()
+        {
+            var sut = CreateSut();
+
+            sut.Initialize();
+
+            _unityContainer.Received().RegisterType<ITestView, TestView>();
+            _unityContainer.Received().RegisterType<ITestViewModel, TestViewModel>();
+        }
+
+        [Test]
+        public void OnInitialized_DoesNotThrow()
+        {
+            var sut = CreateSut();
+
+            Assert.DoesNotThrow(() => sut.OnInitialized(_containerProvider));
+        }
+
+        [Test]
+        public void ImplementIModuleInterface()
+        {
+            var sut = CreateSut();
+
+            Assert.That(sut, Is.InstanceOf<IModule>());
+        }
+
+        private TestModule CreateSut()
+        {
+            return new TestModule(_unityContainer);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+        }
+    }
+
+    public class TestModule : IModule
+    {
+        private readonly IUnityContainer _unityContainer;
+
+        public TestModule(IUnityContainer unityContainer)
+        {
+            _unityContainer = unityContainer;
+        }
+
+        public void Initialize()
+        {
+            _unityContainer.RegisterType<ITestView, TestView>();
+            _unityContainer.RegisterType<ITestViewModel, TestViewModel>();
+        }
+
+        public void OnInitialized(IContainerProvider containerProvider)
+        {
+        }
+
+        public void RegisterTypes(IContainerRegistry containerRegistry)
+        {
+            Initialize();
+        }
+    }
+
+    public interface ITestView { }
+    public class TestView : ITestView { }
+    public interface ITestViewModel { }
+    public class TestViewModel : ITestViewModel { }
+}

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;
+            }
+        }
+    }
+}

GLM5Analysis/TestScaffolds/ViewModelTestScaffold.cs

@@ -0,0 +1,133 @@
+using System.ComponentModel;
+using NUnit.Framework;
+using NSubstitute;
+using Prism.Events;
+using Prism.Regions;
+using Unity;
+
+namespace YourNamespace.Tests
+{
+    [TestFixture]
+    public class ViewModelShould
+    {
+        private IEventAggregator _eventAggregator;
+        private IRegionManager _regionManager;
+        private IUnityContainer _unityContainer;
+
+        [SetUp]
+        public void Setup()
+        {
+            _eventAggregator = Substitute.For<IEventAggregator>();
+            _regionManager = Substitute.For<IRegionManager>();
+            _unityContainer = Substitute.For<IUnityContainer>();
+        }
+
+        [Test]
+        public void RaisePropertyChanged_WhenPropertyIsSet()
+        {
+            var sut = CreateSut();
+            var eventArgs = new List<PropertyChangedEventArgs>();
+            sut.PropertyChanged += (sender, e) => eventArgs.Add(e);
+
+            sut.SomeProperty = "NewValue";
+
+            Assert.That(eventArgs.Count, Is.EqualTo(1));
+            Assert.That(eventArgs[0].PropertyName, Is.EqualTo(nameof(sut.SomeProperty)));
+        }
+
+        [Test]
+        public void NotRaisePropertyChanged_WhenPropertyIsSetToSameValue()
+        {
+            var sut = CreateSut();
+            sut.SomeProperty = "Value";
+            var eventArgs = new List<PropertyChangedEventArgs>();
+            sut.PropertyChanged += (sender, e) => eventArgs.Add(e);
+
+            sut.SomeProperty = "Value";
+
+            Assert.That(eventArgs.Count, Is.EqualTo(0));
+        }
+
+        [Test]
+        public void ExecuteCommand_WhenCommandIsInvoked()
+        {
+            var sut = CreateSut();
+
+            sut.SomeCommand.Execute(null);
+
+            Assert.That(sut.SomeCommandWasExecuted, Is.True);
+        }
+
+        [Test]
+        public void PublishEvent_WhenActionIsPerformed()
+        {
+            var testEvent = Substitute.For<TestEvent>();
+            _eventAggregator.GetEvent<TestEvent>().Returns(testEvent);
+            var sut = CreateSut();
+
+            sut.PerformAction();
+
+            testEvent.Received(1).Publish(Arg.Any<TestPayload>());
+        }
+
+        [Test]
+        public void SubscribeToEvents_WhenInitialized()
+        {
+            var testEvent = Substitute.For<TestEvent>();
+            _eventAggregator.GetEvent<TestEvent>().Returns(testEvent);
+
+            var sut = CreateSut();
+
+            testEvent.Received(1).Subscribe(Arg.Any<Action<TestPayload>>());
+        }
+
+        private TestViewModel CreateSut()
+        {
+            return new TestViewModel(_regionManager, _eventAggregator, _unityContainer);
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+        }
+    }
+
+    public class TestViewModel : INotifyPropertyChanged
+    {
+        public event PropertyChangedEventHandler PropertyChanged;
+        private string _someProperty;
+        public string SomeProperty
+        {
+            get => _someProperty;
+            set
+            {
+                if (_someProperty != value)
+                {
+                    _someProperty = value;
+                    OnPropertyChanged(nameof(SomeProperty));
+                }
+            }
+        }
+
+        public DelegateCommand SomeCommand { get; }
+        public bool SomeCommandWasExecuted { get; private set; }
+
+        public TestViewModel(IRegionManager regionManager, IEventAggregator eventAggregator, IUnityContainer unityContainer)
+        {
+            SomeCommand = new DelegateCommand(() => SomeCommandWasExecuted = true);
+        }
+
+        public void PerformAction() { }
+        protected void OnPropertyChanged(string propertyName) =>
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+    }
+
+    public class TestEvent : PubSubEvent<TestPayload> { }
+    public class TestPayload { }
+    public class DelegateCommand
+    {
+        private readonly Action _execute;
+        public DelegateCommand(Action execute) => _execute = execute;
+        public void Execute(object parameter) => _execute();
+    }
+}