bc-code-intelligence-mcp 1.5.6 → 1.5.8

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.

package/embedded-knowledge/domains/roger-reviewer/samples/testability-code-smells.md

@@ -0,0 +1,256 @@
+# Testability Code Smell Examples
+
+## Code Smell #1: Direct BC Table Access
+
+### ❌ Problematic Code
+```al
+procedure CalculateCustomerDiscount(CustomerNo: Code[20]; Amount: Decimal): Decimal
+var
+    Customer: Record Customer;
+    CustomerPriceGroup: Record "Customer Price Group";
+    DiscountPct: Decimal;
+begin
+    // Direct access to BC tables
+    Customer.Get(CustomerNo);
+    Customer.TestField("Customer Price Group");
+    
+    CustomerPriceGroup.Get(Customer."Customer Price Group");
+    DiscountPct := CustomerPriceGroup."Discount %";
+    
+    if Customer."Allow Line Disc." then
+        DiscountPct += 5;
+        
+    exit(Amount * DiscountPct / 100);
+end;
+```
+
+### Why It's Problematic
+To test this, you need:
+- A Customer record with specific fields populated
+- A Customer Price Group record
+- Proper relationships between them
+
+Test becomes:
+```al
+[Test]
+procedure Test_CustomerDiscount()
+begin
+    // [GIVEN] Customer with price group
+    LibrarySales.CreateCustomer(Customer);
+    Customer."Allow Line Disc." := true;
+    Customer.Modify();
+    
+    // [GIVEN] Price group with discount
+    CreateCustomerPriceGroup(PriceGroup);
+    PriceGroup."Discount %" := 10;
+    PriceGroup.Modify();
+    
+    Customer."Customer Price Group" := PriceGroup.Code;
+    Customer.Modify();
+    
+    // You're testing BC table relationships, not your discount logic!
+```
+
+### ✅ Better: Separate Data Access from Logic
+```al
+// Interface for getting discount configuration
+interface IDiscountConfiguration
+{
+    procedure GetBaseDiscount(CustomerNo: Code[20]): Decimal;
+    procedure AllowsLineDiscount(CustomerNo: Code[20]): Boolean;
+}
+
+// Business logic - testable
+procedure CalculateDiscount(Amount: Decimal; BaseDiscount: Decimal; AllowLineDiscount: Boolean): Decimal
+var
+    TotalDiscount: Decimal;
+begin
+    TotalDiscount := BaseDiscount;
+    if AllowLineDiscount then
+        TotalDiscount += 5;
+    exit(Amount * TotalDiscount / 100);
+end;
+```
+
+---
+
+## Code Smell #2: Tests Full of Unrelated GIVENs
+
+### ❌ Problematic Test
+```al
+[Test]
+procedure Test_CalculateShippingCost()
+var
+    Customer: Record Customer;
+    Item: Record Item;
+    SalesHeader: Record "Sales Header";
+    SalesLine: Record "Sales Line";
+    ShippingAgent: Record "Shipping Agent";
+    ShippingService: Record "Shipping Agent Services";
+begin
+    // [GIVEN] Customer  
+    LibrarySales.CreateCustomer(Customer);
+    
+    // [GIVEN] Shipping Agent with service
+    LibraryInventory.CreateShippingAgent(ShippingAgent);
+    LibraryInventory.CreateShippingAgentService(ShippingAgent.Code, ShippingService);
+    ShippingService."Shipping Cost" := 10;
+    ShippingService.Modify();
+    
+    // [GIVEN] Item with weight
+    LibraryInventory.CreateItem(Item);
+    Item."Gross Weight" := 5;
+    Item.Modify();
+    
+    // [GIVEN] Sales Order
+    LibrarySales.CreateSalesHeader(SalesHeader, SalesHeader."Document Type"::Order, Customer."No.");
+    SalesHeader."Shipping Agent Code" := ShippingAgent.Code;
+    SalesHeader."Shipping Agent Service Code" := ShippingService.Code;
+    SalesHeader.Modify();
+    
+    // [GIVEN] Sales Line
+    LibrarySales.CreateSalesLine(SalesLine, SalesHeader, SalesLine.Type::Item, Item."No.", 10);
+    
+    // [WHEN] Calculate shipping
+    ShippingCalculator.Calculate(SalesHeader);
+    
+    // [THEN] Cost is correct
+    SalesHeader.Find();
+    Assert.AreEqual(50, SalesHeader."Shipping Cost", 'Expected 5kg * 10 units * $1/kg');
+end;
+```
+
+### Why It's Problematic
+- 25 lines of GIVEN for 2 lines of WHEN/THEN
+- Most GIVENs satisfy BC table requirements, not business logic
+- If BC changes Customer or Item structure, test breaks
+- Slow due to database operations
+
+### ✅ Better: Test the Calculation Directly
+```al
+[Test]
+procedure Test_CalculateShippingCost()
+var
+    Calculator: Codeunit "Shipping Calculator";
+    Weight: Decimal;
+    CostPerKg: Decimal;
+    ExpectedCost: Decimal;
+begin
+    // [GIVEN] Known weight and cost rate
+    Weight := 50;  // 5kg * 10 units
+    CostPerKg := 1;
+    
+    // [WHEN] Calculate shipping cost
+    ActualCost := Calculator.CalculateCost(Weight, CostPerKg);
+    
+    // [THEN] Cost is weight * rate
+    Assert.AreEqual(50, ActualCost, 'Weight * CostPerKg');
+end;
+```
+
+---
+
+## Code Smell #3: Assertions Testing BC Behavior
+
+### ❌ Problematic Test
+```al
+[Test]
+procedure Test_CurrencyConversion()
+begin
+    // [GIVEN] Currencies and exchange rates
+    LibraryERM.CreateCurrency(FromCurrency);
+    LibraryERM.CreateCurrency(ToCurrency);
+    LibraryERM.CreateExchangeRate(FromCurrency.Code, WorkDate(), 10, 10);
+    LibraryERM.CreateExchangeRate(ToCurrency.Code, WorkDate(), 0.1, 0.1);
+    
+    // [WHEN] Convert 1 unit
+    Amount := Converter.Convert(1, FromCurrency.Code, ToCurrency.Code);
+    
+    // [THEN] Amount is converted correctly
+    Assert.AreEqual(0.01, Amount, 'Conversion incorrect');
+    // ^^^ Do you even know WHY this should be 0.01?
+end;
+```
+
+### Why It's Problematic
+- The expected value (0.01) comes from BC's calculation, not your knowledge
+- You're testing BC's exchange rate math, not your code
+- If BC changes rounding rules, your test breaks (but your code might be fine)
+
+### ✅ Better: Use a Stub with Known Values
+```al
+[Test]
+procedure Test_ConversionProcessFlow()
+var
+    StubConverter: Codeunit "Stub Currency Converter";
+    SpyLogger: Codeunit "Spy Logger";
+begin
+    // [GIVEN] Converter that returns known value
+    StubConverter.SetReturnValue(42);
+    
+    // [WHEN] Conversion performed
+    Amount := MyProcess.Convert(100, 'USD', 'EUR', StubConverter, SpyLogger);
+    
+    // [THEN] Process returns converter's result
+    Assert.AreEqual(42, Amount, 'Should return converter result');
+    
+    // [THEN] Logger captured correct input
+    Assert.AreEqual(100, SpyLogger.GetCapturedInputAmount(), 'Input logged');
+end;
+```
+
+---
+
+## Code Smell #4: DeleteAll in Test Setup
+
+### ❌ Problematic Test
+```al
+[Test]
+procedure Test_CreateLogEntry()
+var
+    IntegrationLog: Record "Integration Log";
+begin
+    // [GIVEN] No existing entries
+    IntegrationLog.DeleteAll();  // ❌ Modifying shared state
+    
+    // [WHEN] Process runs
+    IntegrationProcess.Run();
+    
+    // [THEN] One entry created
+    Assert.AreEqual(1, IntegrationLog.Count(), 'Expected one entry');
+end;
+```
+
+### Why It's Problematic
+- Modifies database state that other tests might depend on
+- "No existing entries" is NOT a realistic business scenario
+- Test depends on counting records, not verifying behavior
+
+### ✅ Better: Use a Spy Logger
+```al
+[Test]
+procedure Test_ProcessLogsExecution()
+var
+    SpyLogger: Codeunit "Spy Logger";
+begin
+    // [WHEN] Process runs with spy logger
+    IntegrationProcess.Run(SpyLogger);
+    
+    // [THEN] Logger was invoked
+    Assert.IsTrue(SpyLogger.WasInvoked(), 'Should log execution');
+    Assert.AreEqual('IntegrationProcess', SpyLogger.GetLastOperation(), 'Operation name');
+end;
+```
+
+---
+
+## Quick Reference: Smells and Fixes
+
+| Smell | Symptom | Fix |
+|-------|---------|-----|
+| Direct BC table access | Can't test without database | Interface abstraction |
+| Too many GIVENs | Test setup >> test logic | Dependency injection |
+| Asserting BC values | You calculated expected from BC | Stub with known values |
+| DeleteAll in setup | Cleaning shared state | Spy/Mock instead |
+| Setup switch | `case Setup.Type of` | Interface polymorphism |
+| Mixed data + logic | Single proc does both | Separate into layers |