@jwikman/bc-code-intelligence-mcp 1.5.7-dev.1

package/embedded-knowledge/domains/quinn-tester/samples/isolation-testing-patterns.md

@@ -0,0 +1,424 @@
+# Isolation Testing Pattern Samples
+
+## Complete Test Double Library
+
+### Dummy - Does Nothing
+```al
+codeunit 80001 "Dummy Currency Converter" implements ICurrencyConverter
+{
+    procedure Convert(AtDate: Date; FromCurrency: Code[10]; ToCurrency: Code[10]; Amount: Decimal): Decimal
+    begin
+        // Does nothing - just satisfies interface requirement
+        // Use when converter won't be called in your test path
+    end;
+}
+
+codeunit 80002 "Dummy Logger" implements ILogger
+{
+    procedure Log(FromCurrency: Code[10]; ToCurrency: Code[10]; FromAmount: Decimal; ToAmount: Decimal; UserID: Text[50])
+    begin
+        // Does nothing
+    end;
+}
+
+codeunit 80003 "Dummy Permission Checker" implements IPermissionChecker
+{
+    procedure CanConvert(FromCurrency: Code[10]; ToCurrency: Code[10]; UserID: Text[50]): Boolean
+    begin
+        // Default: allow everything
+        exit(true);
+    end;
+}
+```
+
+### Stub - Returns Predetermined Values
+```al
+codeunit 80010 "Stub Currency Converter" implements ICurrencyConverter
+{
+    var
+        ReturnValue: Decimal;
+
+    procedure Convert(AtDate: Date; FromCurrency: Code[10]; ToCurrency: Code[10]; Amount: Decimal): Decimal
+    begin
+        exit(ReturnValue);
+    end;
+
+    procedure SetReturnValue(Value: Decimal)
+    begin
+        ReturnValue := Value;
+    end;
+}
+
+codeunit 80011 "Stub Permission Checker" implements IPermissionChecker
+{
+    var
+        AllowConversion: Boolean;
+
+    procedure CanConvert(FromCurrency: Code[10]; ToCurrency: Code[10]; UserID: Text[50]): Boolean
+    begin
+        exit(AllowConversion);
+    end;
+
+    procedure SetAllowed(Allowed: Boolean)
+    begin
+        AllowConversion := Allowed;
+    end;
+}
+```
+
+### Spy - Records What Happened
+```al
+codeunit 80020 "Spy Logger" implements ILogger
+{
+    var
+        WasInvoked: Boolean;
+        InvokeCount: Integer;
+        LastFromCurrency: Code[10];
+        LastToCurrency: Code[10];
+        LastFromAmount: Decimal;
+        LastToAmount: Decimal;
+        LastUserID: Text[50];
+
+    procedure Log(FromCurrency: Code[10]; ToCurrency: Code[10]; FromAmount: Decimal; ToAmount: Decimal; UserID: Text[50])
+    begin
+        WasInvoked := true;
+        InvokeCount += 1;
+        LastFromCurrency := FromCurrency;
+        LastToCurrency := ToCurrency;
+        LastFromAmount := FromAmount;
+        LastToAmount := ToAmount;
+        LastUserID := UserID;
+    end;
+
+    // Inspection methods
+    procedure IsInvoked(): Boolean
+    begin
+        exit(WasInvoked);
+    end;
+
+    procedure GetInvokeCount(): Integer
+    begin
+        exit(InvokeCount);
+    end;
+
+    procedure GetLastFromCurrency(): Code[10]
+    begin
+        exit(LastFromCurrency);
+    end;
+
+    procedure GetLastToCurrency(): Code[10]
+    begin
+        exit(LastToCurrency);
+    end;
+
+    procedure GetLastFromAmount(): Decimal
+    begin
+        exit(LastFromAmount);
+    end;
+
+    procedure GetLastToAmount(): Decimal
+    begin
+        exit(LastToAmount);
+    end;
+
+    procedure GetLastUserID(): Text[50]
+    begin
+        exit(LastUserID);
+    end;
+
+    procedure Reset()
+    begin
+        WasInvoked := false;
+        InvokeCount := 0;
+        Clear(LastFromCurrency);
+        Clear(LastToCurrency);
+        Clear(LastFromAmount);
+        Clear(LastToAmount);
+        Clear(LastUserID);
+    end;
+}
+
+codeunit 80021 "Spy Currency Converter" implements ICurrencyConverter
+{
+    var
+        WasInvoked: Boolean;
+        CapturedDate: Date;
+        CapturedFromCurrency: Code[10];
+        CapturedToCurrency: Code[10];
+        CapturedAmount: Decimal;
+        ReturnValue: Decimal;
+
+    procedure Convert(AtDate: Date; FromCurrency: Code[10]; ToCurrency: Code[10]; Amount: Decimal): Decimal
+    begin
+        WasInvoked := true;
+        CapturedDate := AtDate;
+        CapturedFromCurrency := FromCurrency;
+        CapturedToCurrency := ToCurrency;
+        CapturedAmount := Amount;
+        exit(ReturnValue);
+    end;
+
+    procedure SetReturnValue(Value: Decimal)
+    begin
+        ReturnValue := Value;
+    end;
+
+    procedure IsInvoked(): Boolean
+    begin
+        exit(WasInvoked);
+    end;
+
+    procedure GetCapturedDate(): Date
+    begin
+        exit(CapturedDate);
+    end;
+
+    procedure GetCapturedFromCurrency(): Code[10]
+    begin
+        exit(CapturedFromCurrency);
+    end;
+
+    procedure GetCapturedToCurrency(): Code[10]
+    begin
+        exit(CapturedToCurrency);
+    end;
+
+    procedure GetCapturedAmount(): Decimal
+    begin
+        exit(CapturedAmount);
+    end;
+}
+```
+
+### Throwing Test Double - Simulates Errors
+```al
+codeunit 80030 "Throwing Converter" implements ICurrencyConverter
+{
+    var
+        ErrorMessage: Text;
+
+    procedure Convert(AtDate: Date; FromCurrency: Code[10]; ToCurrency: Code[10]; Amount: Decimal): Decimal
+    begin
+        if ErrorMessage <> '' then
+            Error(ErrorMessage);
+        Error('Simulated conversion failure');
+    end;
+
+    procedure SetErrorMessage(Message: Text)
+    begin
+        ErrorMessage := Message;
+    end;
+}
+```
+
+---
+
+## Complete Test Codeunit Example
+
+```al
+codeunit 80100 "Currency Conversion Tests"
+{
+    Subtype = Test;
+
+    var
+        Assert: Codeunit Assert;
+        CurrencyConversion: Codeunit "Currency Conversion";
+
+    [Test]
+    procedure Test_01_SuccessfulConversion()
+    var
+        StubPermission: Codeunit "Stub Permission Checker";
+        StubConverter: Codeunit "Stub Currency Converter";
+        SpyLogger: Codeunit "Spy Logger";
+        Result: Decimal;
+    begin
+        // [SCENARIO] Successful currency conversion logs the result
+        
+        // [GIVEN] Permission granted
+        StubPermission.SetAllowed(true);
+        
+        // [GIVEN] Converter returns known value
+        StubConverter.SetReturnValue(100);
+        
+        // [WHEN] Conversion is performed
+        Result := CurrencyConversion.Convert(50, 'USD', 'EUR', StubPermission, StubConverter, SpyLogger);
+        
+        // [THEN] Result is converter's return value
+        Assert.AreEqual(100, Result, 'Should return converter result');
+        
+        // [THEN] Logger was invoked with correct values
+        Assert.IsTrue(SpyLogger.IsInvoked(), 'Logger should be invoked');
+        Assert.AreEqual('USD', SpyLogger.GetLastFromCurrency(), 'From currency');
+        Assert.AreEqual('EUR', SpyLogger.GetLastToCurrency(), 'To currency');
+        Assert.AreEqual(50, SpyLogger.GetLastFromAmount(), 'From amount');
+        Assert.AreEqual(100, SpyLogger.GetLastToAmount(), 'To amount (converter result)');
+    end;
+
+    [Test]
+    procedure Test_02_PermissionDenied_NoConversion()
+    var
+        StubPermission: Codeunit "Stub Permission Checker";
+        DummyConverter: Codeunit "Dummy Currency Converter";
+        SpyLogger: Codeunit "Spy Logger";
+    begin
+        // [SCENARIO] Permission denied prevents conversion and logging
+        
+        // [GIVEN] Permission denied
+        StubPermission.SetAllowed(false);
+        
+        // [WHEN] Conversion is attempted
+        asserterror CurrencyConversion.Convert(50, 'USD', 'EUR', StubPermission, DummyConverter, SpyLogger);
+        
+        // [THEN] Error is raised
+        Assert.ExpectedError('not allowed');
+        
+        // [THEN] Logger was NOT invoked
+        Assert.IsFalse(SpyLogger.IsInvoked(), 'Logger should not be invoked on permission failure');
+    end;
+
+    [Test]
+    procedure Test_03_ConverterParameters()
+    var
+        StubPermission: Codeunit "Stub Permission Checker";
+        SpyConverter: Codeunit "Spy Currency Converter";
+        DummyLogger: Codeunit "Dummy Logger";
+    begin
+        // [SCENARIO] Converter receives correct parameters
+        
+        // [GIVEN] Permission granted
+        StubPermission.SetAllowed(true);
+        SpyConverter.SetReturnValue(999);
+        
+        // [WHEN] Conversion with specific values
+        CurrencyConversion.Convert(123.45, 'GBP', 'JPY', StubPermission, SpyConverter, DummyLogger);
+        
+        // [THEN] Converter received correct parameters
+        Assert.IsTrue(SpyConverter.IsInvoked(), 'Converter should be called');
+        Assert.AreEqual('GBP', SpyConverter.GetCapturedFromCurrency(), 'From currency');
+        Assert.AreEqual('JPY', SpyConverter.GetCapturedToCurrency(), 'To currency');
+        Assert.AreEqual(123.45, SpyConverter.GetCapturedAmount(), 'Amount');
+        Assert.AreEqual(WorkDate(), SpyConverter.GetCapturedDate(), 'Date should be WorkDate');
+    end;
+
+    [Test]
+    procedure Test_04_ConverterFailure_Propagates()
+    var
+        StubPermission: Codeunit "Stub Permission Checker";
+        ThrowingConverter: Codeunit "Throwing Converter";
+        SpyLogger: Codeunit "Spy Logger";
+    begin
+        // [SCENARIO] Converter errors propagate correctly
+        
+        // [GIVEN] Permission granted
+        StubPermission.SetAllowed(true);
+        
+        // [GIVEN] Converter will fail
+        ThrowingConverter.SetErrorMessage('External service unavailable');
+        
+        // [WHEN] Conversion is attempted
+        asserterror CurrencyConversion.Convert(50, 'USD', 'EUR', StubPermission, ThrowingConverter, SpyLogger);
+        
+        // [THEN] Converter error propagates
+        Assert.ExpectedError('service unavailable');
+        
+        // [THEN] Logger was NOT invoked (conversion failed)
+        Assert.IsFalse(SpyLogger.IsInvoked(), 'Logger should not be invoked on conversion failure');
+    end;
+
+    [Test]
+    procedure Test_05_MultipleConversions()
+    var
+        StubPermission: Codeunit "Stub Permission Checker";
+        StubConverter: Codeunit "Stub Currency Converter";
+        SpyLogger: Codeunit "Spy Logger";
+    begin
+        // [SCENARIO] Multiple conversions each logged separately
+        
+        // [GIVEN] Permission granted
+        StubPermission.SetAllowed(true);
+        StubConverter.SetReturnValue(100);
+        
+        // [WHEN] Two conversions performed
+        CurrencyConversion.Convert(10, 'USD', 'EUR', StubPermission, StubConverter, SpyLogger);
+        CurrencyConversion.Convert(20, 'GBP', 'JPY', StubPermission, StubConverter, SpyLogger);
+        
+        // [THEN] Logger invoked twice
+        Assert.AreEqual(2, SpyLogger.GetInvokeCount(), 'Logger should be invoked twice');
+        
+        // [THEN] Last call has correct values
+        Assert.AreEqual('GBP', SpyLogger.GetLastFromCurrency(), 'Last from currency');
+        Assert.AreEqual('JPY', SpyLogger.GetLastToCurrency(), 'Last to currency');
+    end;
+}
+```
+
+---
+
+## Testing Production Implementations Separately
+
+```al
+codeunit 80110 "Database Permission Checker Tests"
+{
+    Subtype = Test;
+
+    var
+        Assert: Codeunit Assert;
+
+    [Test]
+    procedure Test_PermissionExists_ReturnsTrue()
+    var
+        Permission: Record "Currency Exchange Permission";
+        PermissionChecker: Codeunit "Database Permission Checker";
+    begin
+        // [GIVEN] Permission record exists
+        Permission."User ID" := 'TESTUSER';
+        Permission."From Currency Code" := 'USD';
+        Permission."To Currency Code" := 'EUR';
+        Permission.Insert(false);
+        
+        // [WHEN] Check permission
+        // [THEN] Returns true
+        Assert.IsTrue(
+            PermissionChecker.CanConvert('USD', 'EUR', 'TESTUSER'),
+            'Should allow when permission exists'
+        );
+    end;
+
+    [Test]
+    procedure Test_NoPermission_ReturnsFalse()
+    var
+        PermissionChecker: Codeunit "Database Permission Checker";
+    begin
+        // [GIVEN] No permission records for this user/currency combination
+        
+        // [WHEN] Check permission
+        // [THEN] Returns false
+        Assert.IsFalse(
+            PermissionChecker.CanConvert('XXX', 'YYY', 'UNKNOWNUSER'),
+            'Should deny when no permission exists'
+        );
+    end;
+
+    [Test]
+    procedure Test_WildcardPermission_AllowsAnyCurrency()
+    var
+        Permission: Record "Currency Exchange Permission";
+        PermissionChecker: Codeunit "Database Permission Checker";
+    begin
+        // [GIVEN] Wildcard permission (empty currency codes)
+        Permission."User ID" := 'SUPERUSER';
+        Permission."From Currency Code" := '';  // Any
+        Permission."To Currency Code" := '';    // Any
+        Permission.Insert(false);
+        
+        // [WHEN] Check any currency combination
+        // [THEN] Returns true for any currencies
+        Assert.IsTrue(
+            PermissionChecker.CanConvert('ABC', 'XYZ', 'SUPERUSER'),
+            'Wildcard should allow any currencies'
+        );
+    end;
+}
+```
+
+**Key Point**: Test your production implementations directly with simple, focused tests. Then use test doubles when testing business logic that USES those implementations.