Merge pull request #286 from microsoft/add-kine-knowledge-gap-article

Add article: AI for BC Development - The Knowledge Gap That Ships to Production

content/_index.md

@@ -125,14 +125,14 @@ images: ["images/og-image-fission.png"]
         <div class="card-shadow">
           <span class="card-badge">NEW</span>
           <h4 class="section-text-bold mt-4">
-            Vibe Coding for AL
+            Getting Started With Agentic Coding
           </h4>
           <div class="card-shadow-content">
             <p class="section-text">
-              AI-optimized coding rules and guidelines designed to enhance the AL developer experience in modern AI-powered IDEs like VS Code and Cursor.
+              Essential concepts and practices for working with AI coding assistants in your AL development workflow.
             </p>
-            <a href="/docs/vibe-coding/">
-              <button class="hero-mid-2 align-self-end">Explore Rules</button>
+            <a href="/docs/agentic-coding/gettingstarted/">
+              <button class="hero-mid-2 align-self-end">Get Started</button>
             </a>
           </div>
         </div>
@@ -140,16 +140,16 @@ images: ["images/og-image-fission.png"]
 
   <div class="col-lg-4">
         <div class="card-shadow">
-          <span class="card-badge">TAG</span>
+          <span class="card-badge">GUIDE</span>
           <h4 class="section-text-bold mt-4">
-            API
+            Vibe Coding Rules
           </h4>
           <div class="card-shadow-content">
             <p class="section-text">
-              Two API Related Design Patterns and one Best Practice for working with API's
+              AI-optimized coding rules and guidelines designed to enhance the AL developer experience in modern AI-powered IDEs.
             </p>
-            <a href="/tags/api/"
-              ><button class="hero-mid-2 align-self-end">Read Now</button></a
+            <a href="/docs/agentic-coding/vibe-coding-rules/"
+              ><button class="hero-mid-2 align-self-end">Explore Rules</button></a
             >
           </div>
         </div>
@@ -157,17 +157,17 @@ images: ["images/og-image-fission.png"]
 
   <div class="col-lg-4">
         <div class="card-shadow">
-          <span class="card-badge">PATTERN</span>
+          <span class="card-badge">TOOLS</span>
           <h4 class="section-text-bold mt-4">
-            Event Bridge
+            Agentic Tools
           </h4>
           <div class="card-shadow-content">
             <p class="section-text">
-             In the world of interfaces, it is important to preserve (certain) events over multiple implementation of the interface.
+              Model Context Protocol (MCP) servers that enhance AI assistants for Business Central development workflows.
             </p>
             <a
-              href="/docs/patterns/event-bridge-pattern/"
-              ><button class="hero-mid-2 align-self-end">Read Now</button></a
+              href="/docs/agentic-coding/communityresources/tools/"
+              ><button class="hero-mid-2 align-self-end">Explore Tools</button></a
             >
           </div>
         </div>
@@ -210,17 +210,6 @@ images: ["images/og-image-fission.png"]
                 </p>
               </div>
             </a>
-            <a href="https://twitter.com/search?q=%23bcalhelp">
-              <div class="card-shadow twitter-card" style="margin-left: auto">
-                <div class="card-header-custom">
-                  <h2 style="padding-right: 0.8rem;"><i class="fab fa-twitter"></i></h2>
-                  <h2 class="section-text-bold">Twitter</h2>
-                </div>
-                <p class="section-text">
-                  Chat about this with the <b class="text-highlight">#bcalhelp</b> hashtag.
-                </p>
-              </div>
-            </a>
           </div>
         </div>
       </div>
@@ -254,22 +243,6 @@ images: ["images/og-image-fission.png"]
               </div></a
             >
           </div>
-          <div class="col-lg-6">
-            <a href="https://twitter.com/search?q=%23bcalhelp"
-              ><div
-                class="card-shadow twitter-card-desktop"
-                style="margin-left: auto"
-              >
-                <div class="card-header-custom">
-                  <h2 style="padding-right: 0.8rem;"><i class="fab fa-twitter"></i></h2>
-                  <h2 class="section-text-bold">Twitter</h2>
-                </div>
-                <p class="section-text">
-                  Chat about this with the <b class="text-highlight">#bcalhelp</b> hashtag.
-                </p>
-              </div></a
-            >
-          </div>
         </div>
       </div>
     </div>

content/docs/NAVPatterns/3-cal-coding-guidelines/_index.md

@@ -23,6 +23,6 @@ We're looking forward to your comments. Where you can, do provide concrete examp
 
 
 
-[anchor0]: https://blogs.msdn.microsoft.com/nav/2015/01/09/cal-coding-guidelines-used-at-microsoft-development-center-copenhagen "download the C/AL coding guidelines as pdf"
+[anchor0]: /files/CAL-Coding-Guidelines-at-Microsoft-Development-Center-Copenhagen.pdf "download the C/AL coding guidelines as pdf"
 [anchor1]: /members/waldo/default.aspx "waldo"
 [anchor2]: https://www.youtube.com/watch?v=z6skKy0pkmU&list=PLhZ3P-LY7CqmVszuvtJLujFyHpsVN0U_w&index=26

content/docs/NAVPatterns/patterns/blocked-entity/_index.md

@@ -92,7 +92,9 @@ Entities where the Blocked Entity has been implemented include:
 
 The [Released Entity][anchor4].
 
-{{< youtube O2R-fTSup1o >}}
+{{% alert title="Note" %}}
+There was previously a video demonstration of this pattern, but it is no longer available.
+{{% /alert %}}
 
 [anchor0]: 2260.BlockedEntityPattern.png
 [anchor1]: /navpatterns/1-patterns/blocked-entity/data-driven-blocked-entity/

content/docs/agentic-coding/CommunityResources/Tools/al-development-collection.md

@@ -0,0 +1,49 @@
+---
+title: "AL Development Collection"
+linkTitle: "AL Development Collection"
+weight: 1
+description: >
+  AI Native AL Development toolkit with 37 Agent Primitives for systematic Business Central development
+---
+
+## Overview
+
+The AL Development Collection provides a complete AI-native development toolkit for Microsoft Dynamics 365 Business Central. Instead of ad-hoc AI usage, you get systematic engineering through 37 Agent Primitives organized across 3 framework layers implementing the AI Native-Instructions Architecture.
+
+**Created by**: [Javier Armesto](https://github.com/javiarmesto)
+
+---
+
+## Key Features
+
+**6 Role-Based Specialist Agents**:
+- al-architect 🏗️ (solution design), al-developer 💻 (implementation), al-debugger 🐛 (troubleshooting)
+- al-tester ✅ (TDD/quality), al-api 🌐 (API development), al-copilot 🤖 (AI features)
+
+**4 Orchestra System Agents** (Multi-agent TDD):
+- al-conductor 🎭 (orchestration), al-planning-subagent 🔍 (research)
+- al-implement-subagent 💻 (TDD implementation), al-review-subagent ✅ (validation)
+
+**9 Auto-Applied Instructions**:
+- Code style, naming conventions, performance patterns
+- Error handling, events, testing standards
+- Context-aware loading via `applyTo` patterns
+
+**18 Agentic Workflows**:
+- Environment setup (al-initialize, al-build)
+- Development (al-events, al-pages, al-permissions)
+- Analysis (al-diagnose, al-performance, al-migrate)
+- Copilot features (al-copilot-capability, al-copilot-promptdialog, al-copilot-test)
+
+**Smart Complexity Routing (Experimental)**:
+- 🟢 LOW → al-developer (direct implementation)
+- 🟡 MEDIUM → al-conductor (TDD orchestration)
+- 🔴 HIGH → al-architect → al-conductor (full design + TDD)
+
+---
+
+## Links
+
+- **GitHub**: https://github.com/javiarmesto/AL-Development-Collection-for-GitHub-Copilot
+- **Quick Start**: https://github.com/javiarmesto/AL-Development-Collection-for-GitHub-Copilot/blob/main/QUICK-START.md
+- **Complete Development Flow**: https://github.com/javiarmesto/AL-Development-Collection-for-GitHub-Copilot/blob/main/docs/workflows/complete-development-flow.md

content/docs/agentic-coding/CommunityResources/articles.md

@@ -14,6 +14,21 @@ This page curates blog posts, articles, and written guides from the Business Cen
 
 ### Getting Started
 
+#### "AI for BC Development - The Knowledge Gap That Ships to Production" — Kine
+**Author**: Kine (blog.kine.cz)
+**Published**: 2025
+**Summary**: A critical self-assessment guide on whether you are ready to validate what AI produces for BC development. Covers common AI mistakes in AL code (wrong field assignment, missing keys, reinventing standard libraries) and what BC knowledge areas you need to review AI output responsibly.
+
+**Key Takeaways**:
+- Common AI mistakes in AL code that ship to production
+- Self-assessment framework for AI-assisted development readiness
+- BC knowledge areas required to review AI output responsibly
+- Practical examples of wrong field assignments, missing keys, and reinvented standard libraries
+
+**Link**: https://blog.kine.cz/posts/bcdevelopmentserie-02b/
+
+---
+
 #### "Vibe Coding — yes or no?" — Demiliani
 **Author**: Demiliani
 **Published**: 2025-08-21

content/docs/agentic-coding/GettingMore/testing.md

@@ -0,0 +1,902 @@
+---
+title: "Writing Tests"
+linkTitle: "Testing"
+weight: 5
+description: >
+  Use AI to create comprehensive test coverage for your AL code
+---
+
+## Scenario
+
+You've developed new features for your Business Central extension, but you need comprehensive test coverage to:
+
+- Ensure code works as expected
+- Prevent regressions when making changes
+- Document expected behavior
+- Enable confident refactoring
+- Meet quality standards
+
+Writing tests manually is time-consuming, and you want to use AI to accelerate the process while maintaining test quality.
+
+## Goal
+
+Use AI to help you:
+
+- Generate unit tests for individual procedures
+- Create integration tests for complex workflows
+- Design test data and scenarios
+- Write test helpers and fixtures
+- Create mock objects for dependencies
+- Implement data-driven tests
+
+## The Code to Test
+
+Here's a codeunit that needs test coverage:
+
+```al
+codeunit 50100 "Order Discount Manager"
+{
+    procedure CalculateDiscount(var SalesHeader: Record "Sales Header"): Decimal
+    var
+        Customer: Record Customer;
+        DiscountPct: Decimal;
+    begin
+        if not Customer.Get(SalesHeader."Sell-to Customer No.") then
+            Error('Customer %1 not found', SalesHeader."Sell-to Customer No.");
+
+        DiscountPct := GetCustomerDiscount(Customer);
+        DiscountPct += GetVolumeDiscount(SalesHeader);
+        DiscountPct += GetSeasonalDiscount();
+
+        if DiscountPct > 50 then
+            DiscountPct := 50;
+
+        exit(DiscountPct);
+    end;
+
+    local procedure GetCustomerDiscount(Customer: Record Customer): Decimal
+    begin
+        case Customer."Customer Discount Group" of
+            'VIP':
+                exit(10);
+            'PREMIUM':
+                exit(5);
+            else
+                exit(0);
+        end;
+    end;
+
+    local procedure GetVolumeDiscount(SalesHeader: Record "Sales Header"): Decimal
+    var
+        SalesLine: Record "Sales Line";
+        TotalAmount: Decimal;
+    begin
+        SalesLine.SetRange("Document Type", SalesHeader."Document Type");
+        SalesLine.SetRange("Document No.", SalesHeader."No.");
+        SalesLine.CalcSums("Line Amount");
+        TotalAmount := SalesLine."Line Amount";
+
+        case true of
+            TotalAmount >= 10000:
+                exit(15);
+            TotalAmount >= 5000:
+                exit(10);
+            TotalAmount >= 1000:
+                exit(5);
+            else
+                exit(0);
+        end;
+    end;
+
+    local procedure GetSeasonalDiscount(): Decimal
+    begin
+        if Date2DMY(Today, 2) in [11, 12] then
+            exit(5);
+        exit(0);
+    end;
+}
+```
+
+## Step-by-Step Testing Process
+
+### Step 1: Generate Basic Test Structure
+
+**Prompt**:
+
+```
+Create a test codeunit for the Order Discount Manager.
+
+Include:
+- Proper test codeunit structure with Subtype = Test
+- Setup and teardown if needed
+- Test procedure stubs for all public procedures
+- Use AL test framework conventions
+- Include Assert codeunit
+- Add test isolation attributes where needed
+
+[Include the codeunit code]
+```
+
+**Expected Result**:
+
+```al
+codeunit 50101 "Order Discount Mgr. Tests"
+{
+    Subtype = Test;
+
+    var
+        Assert: Codeunit "Library Assert";
+        LibrarySales: Codeunit "Library - Sales";
+        LibraryUtility: Codeunit "Library - Utility";
+        IsInitialized: Boolean;
+
+    [Test]
+    procedure TestCalculateDiscountBasic()
+    begin
+        // Test basic discount calculation
+    end;
+
+    [Test]
+    procedure TestVIPCustomerDiscount()
+    begin
+        // Test VIP customer gets 10% discount
+    end;
+
+    [Test]
+    procedure TestVolumeDiscountTiers()
+    begin
+        // Test volume discount calculation at different amounts
+    end;
+
+    [Test]
+    procedure TestSeasonalDiscount()
+    begin
+        // Test seasonal discount in November/December
+    end;
+
+    [Test]
+    procedure TestMaximumDiscountCap()
+    begin
+        // Test discount cannot exceed 50%
+    end;
+
+    [Test]
+    procedure TestCustomerNotFoundError()
+    begin
+        // Test error when customer doesn't exist
+    end;
+
+    local procedure Initialize()
+    begin
+        if IsInitialized then
+            exit;
+
+        // Setup code here
+        IsInitialized := true;
+    end;
+}
+```
+
+### Step 2: Implement Happy Path Test
+
+**Prompt**:
+
+```
+Implement the TestCalculateDiscountBasic test using the Given-When-Then pattern.
+
+This test should verify:
+- A standard customer with a medium-size order
+- Gets the expected discount percentage
+- No errors are raised
+
+Use the Library codeunits for test data creation.
+Include clear comments for each section.
+```
+
+**Expected Result**:
+
+```al
+[Test]
+procedure TestCalculateDiscountBasic()
+var
+    Customer: Record Customer;
+    SalesHeader: Record "Sales Header";
+    OrderDiscountMgr: Codeunit "Order Discount Manager";
+    ActualDiscount: Decimal;
+    ExpectedDiscount: Decimal;
+begin
+    // [SCENARIO] Calculate discount for a standard order
+    Initialize();
+
+    // [GIVEN] A standard customer with no special discount group
+    Customer.Get(LibrarySales.CreateCustomerNo());
+    Customer."Customer Discount Group" := '';
+    Customer.Modify();
+
+    // [GIVEN] A sales order with total amount of 2000 (5% volume discount)
+    SalesHeader := CreateSalesOrderWithAmount(Customer."No.", 2000);
+
+    // [GIVEN] Expected discount is 5% (volume only, not in seasonal months)
+    ExpectedDiscount := 5;
+
+    // [WHEN] Calculating the discount
+    ActualDiscount := OrderDiscountMgr.CalculateDiscount(SalesHeader);
+
+    // [THEN] The discount matches expected value
+    Assert.AreEqual(ExpectedDiscount, ActualDiscount, 'Discount calculation incorrect');
+end;
+
+local procedure CreateSalesOrderWithAmount(CustomerNo: Code[20]; TotalAmount: Decimal): Record "Sales Header"
+var
+    SalesHeader: Record "Sales Header";
+    SalesLine: Record "Sales Line";
+    Item: Record Item;
+begin
+    LibrarySales.CreateSalesHeader(SalesHeader, SalesHeader."Document Type"::Order, CustomerNo);
+
+    Item."No." := LibraryUtility.GenerateRandomCode(Item.FieldNo("No."), Database::Item);
+    Item."Unit Price" := TotalAmount;
+    Item.Insert();
+
+    LibrarySales.CreateSalesLine(SalesLine, SalesHeader, SalesLine.Type::Item, Item."No.", 1);
+    SalesLine.Validate("Unit Price", TotalAmount);
+    SalesLine.Modify(true);
+
+    exit(SalesHeader);
+end;
+```
+
+### Step 3: Implement Error Case Tests
+
+**Prompt**:
+
+```
+Implement the TestCustomerNotFoundError test.
+
+This should verify:
+- When an invalid customer number is used
+- An appropriate error is raised
+- The error message contains the customer number
+
+Use asserterror and Assert.ExpectedError.
+```
+
+**Expected Result**:
+
+```al
+[Test]
+procedure TestCustomerNotFoundError()
+var
+    SalesHeader: Record "Sales Header";
+    OrderDiscountMgr: Codeunit "Order Discount Manager";
+    InvalidCustomerNo: Code[20];
+begin
+    // [SCENARIO] Error is raised when customer doesn't exist
+    Initialize();
+
+    // [GIVEN] A sales header with non-existent customer
+    InvalidCustomerNo := 'INVALID123';
+    LibrarySales.CreateSalesHeader(SalesHeader, SalesHeader."Document Type"::Order, '');
+    SalesHeader."Sell-to Customer No." := InvalidCustomerNo;
+    SalesHeader.Modify();
+
+    // [WHEN] Calculating discount for non-existent customer
+    asserterror OrderDiscountMgr.CalculateDiscount(SalesHeader);
+
+    // [THEN] Appropriate error is raised with customer number
+    Assert.ExpectedError(StrSubstNo('Customer %1 not found', InvalidCustomerNo));
+end;
+```
+
+### Step 4: Implement Data-Driven Tests
+
+**Prompt**:
+
+```
+Create a comprehensive test for all customer discount tiers (VIP, PREMIUM, standard).
+
+Use a data-driven approach where one test function tests all scenarios.
+Create a local helper that takes customer group and expected discount as parameters.
+
+Test these scenarios:
+- VIP customer: 10% discount
+- PREMIUM customer: 5% discount
+- Standard customer: 0% discount
+- Empty group: 0% discount
+```
+
+**Expected Result**:
+
+```al
+[Test]
+procedure TestCustomerDiscountTiers()
+begin
+    // [SCENARIO] Different customer types receive appropriate discounts
+    Initialize();
+
+    // [GIVEN] [WHEN] [THEN] VIP customers get 10% discount
+    VerifyCustomerTypeDiscount('VIP', 10);
+
+    // [GIVEN] [WHEN] [THEN] Premium customers get 5% discount
+    VerifyCustomerTypeDiscount('PREMIUM', 5);
+
+    // [GIVEN] [WHEN] [THEN] Standard customers get 0% discount
+    VerifyCustomerTypeDiscount('STANDARD', 0);
+
+    // [GIVEN] [WHEN] [THEN] Customers with no group get 0% discount
+    VerifyCustomerTypeDiscount('', 0);
+end;
+
+local procedure VerifyCustomerTypeDiscount(CustomerGroup: Code[10]; ExpectedDiscount: Decimal)
+var
+    Customer: Record Customer;
+    SalesHeader: Record "Sales Header";
+    OrderDiscountMgr: Codeunit "Order Discount Manager";
+    ActualDiscount: Decimal;
+begin
+    // Create customer with specific group
+    Customer.Get(LibrarySales.CreateCustomerNo());
+    Customer."Customer Discount Group" := CustomerGroup;
+    Customer.Modify();
+
+    // Create order with amount below volume discount threshold (< 1000)
+    SalesHeader := CreateSalesOrderWithAmount(Customer."No.", 500);
+
+    // Calculate discount
+    ActualDiscount := OrderDiscountMgr.CalculateDiscount(SalesHeader);
+
+    // Verify expected discount
+    Assert.AreEqual(ExpectedDiscount, ActualDiscount,
+        StrSubstNo('Incorrect discount for customer group %1', CustomerGroup));
+end;
+```
+
+### Step 5: Test Edge Cases and Boundaries
+
+**Prompt**:
+
+```
+Create tests for volume discount boundary conditions.
+
+Test these specific amounts:
+- 999: Just below 1000 threshold (expect 0% volume discount)
+- 1000: Exactly at threshold (expect 5% volume discount)
+- 4999: Just below 5000 threshold (expect 5% volume discount)
+- 5000: Exactly at threshold (expect 10% volume discount)
+- 9999: Just below 10000 threshold (expect 10% volume discount)
+- 10000: Exactly at threshold (expect 15% volume discount)
+
+Use descriptive test names and clear assertions.
+```
+
+**Expected Result**:
+
+```al
+[Test]
+procedure TestVolumeDiscountBoundaries()
+begin
+    // [SCENARIO] Volume discounts applied at exact thresholds
+    Initialize();
+
+    // Just below first threshold
+    VerifyVolumeDiscount(999, 0, 'Below 1000 threshold');
+
+    // Exactly at first threshold
+    VerifyVolumeDiscount(1000, 5, 'At 1000 threshold');
+
+    // Between first and second threshold
+    VerifyVolumeDiscount(4999, 5, 'Below 5000 threshold');
+
+    // Exactly at second threshold
+    VerifyVolumeDiscount(5000, 10, 'At 5000 threshold');
+
+    // Between second and third threshold
+    VerifyVolumeDiscount(9999, 10, 'Below 10000 threshold');
+
+    // Exactly at third threshold
+    VerifyVolumeDiscount(10000, 15, 'At 10000 threshold');
+end;
+
+local procedure VerifyVolumeDiscount(OrderAmount: Decimal; ExpectedVolumeDiscount: Decimal; Scenario: Text)
+var
+    Customer: Record Customer;
+    SalesHeader: Record "Sales Header";
+    OrderDiscountMgr: Codeunit "Order Discount Manager";
+    ActualDiscount: Decimal;
+begin
+    // Create standard customer (no customer discount)
+    Customer.Get(LibrarySales.CreateCustomerNo());
+    Customer."Customer Discount Group" := '';
+    Customer.Modify();
+
+    // Create order with specific amount
+    SalesHeader := CreateSalesOrderWithAmount(Customer."No.", OrderAmount);
+
+    // Calculate discount (assuming not in seasonal months)
+    ActualDiscount := OrderDiscountMgr.CalculateDiscount(SalesHeader);
+
+    // Verify volume discount
+    Assert.AreEqual(ExpectedVolumeDiscount, ActualDiscount,
+        StrSubstNo('Incorrect volume discount for %1 (amount: %2)', Scenario, OrderAmount));
+end;
+```
+
+### Step 6: Test Maximum Discount Cap
+
+**Prompt**:
+
+```
+Create a test that verifies the 50% maximum discount cap.
+
+Test scenario:
+- VIP customer (10% discount)
+- Large order (15% volume discount)
+- Seasonal period (5% discount)
+- Total would be 30%, which is under cap - verify this works
+- Then test a scenario that would exceed 50% and verify it's capped
+
+Consider: What combination would exceed 50%? We may need to modify setup or mock GetSeasonalDiscount.
+```
+
+**Expected Result**:
+
+```al
+[Test]
+procedure TestMaximumDiscountCap()
+var
+    Customer: Record Customer;
+    SalesHeader: Record "Sales Header";
+    OrderDiscountMgr: Codeunit "Order Discount Manager";
+    ActualDiscount: Decimal;
+begin
+    // [SCENARIO] Discount is capped at 50% even when combined discounts exceed it
+    Initialize();
+
+    // [GIVEN] VIP customer (10% discount)
+    Customer.Get(LibrarySales.CreateCustomerNo());
+    Customer."Customer Discount Group" := 'VIP';
+    Customer.Modify();
+
+    // [GIVEN] Large order (15% volume discount)
+    SalesHeader := CreateSalesOrderWithAmount(Customer."No.", 10000);
+
+    // [GIVEN] If testing in Nov/Dec, total would be 10+15+5=30% (under cap)
+    // [GIVEN] To test cap, we need a scenario that would exceed 50%
+    // Note: With current business logic, max is 30%, so cap isn't reached
+
+    // [WHEN] Calculating discount
+    ActualDiscount := OrderDiscountMgr.CalculateDiscount(SalesHeader);
+
+    // [THEN] Discount doesn't exceed 50%
+    Assert.IsTrue(ActualDiscount <= 50, 'Discount exceeds maximum allowed 50%');
+end;
+
+[Test]
+procedure TestDiscountCapWithMultipleDiscounts()
+var
+    Customer: Record Customer;
+    SalesHeader: Record "Sales Header";
+    OrderDiscountMgr: Codeunit "Order Discount Manager";
+    ActualDiscount: Decimal;
+begin
+    // [SCENARIO] Combined discounts that would exceed 50% are capped
+    // [NOTE] This test may need the business logic modified to make it relevant
+    // Current max possible: 10% (VIP) + 15% (volume) + 5% (seasonal) = 30%
+
+    Initialize();
+
+    // Create scenario with maximum possible discounts
+    Customer.Get(LibrarySales.CreateCustomerNo());
+    Customer."Customer Discount Group" := 'VIP';
+    Customer.Modify();
+
+    SalesHeader := CreateSalesOrderWithAmount(Customer."No.", 10000);
+
+    // Calculate discount
+    ActualDiscount := OrderDiscountMgr.CalculateDiscount(SalesHeader);
+
+    // Verify cap is applied if needed
+    Assert.IsTrue(ActualDiscount <= 50, 'Discount cap not enforced');
+end;
+```
+
+### Step 7: Test Time-Dependent Logic
+
+**Prompt**:
+
+```
+Create tests for the seasonal discount that depends on the current date.
+
+Since GetSeasonalDiscount uses Today, we need to:
+1. Test behavior for November (month 11)
+2. Test behavior for December (month 12)
+3. Test behavior for other months
+
+Explain how to handle date-dependent tests in AL.
+Options:
+- Make the date a parameter (refactor code)
+- Use test isolation / mocking
+- Create tests that work year-round
+```
+
+**Expected Result**:
+
+```al
+[Test]
+procedure TestSeasonalDiscountInNovember()
+var
+    Customer: Record Customer;
+    SalesHeader: Record "Sales Header";
+    OrderDiscountMgr: Codeunit "Order Discount Manager";
+    ActualDiscount: Decimal;
+    CurrentMonth: Integer;
+begin
+    // [SCENARIO] Seasonal discount is applied in November
+    // [NOTE] This test only passes when run in November
+
+    Initialize();
+
+    CurrentMonth := Date2DMY(Today, 2);
+    if CurrentMonth <> 11 then
+        exit; // Skip test if not November
+
+    // [GIVEN] Standard customer with small order (no other discounts)
+    Customer.Get(LibrarySales.CreateCustomerNo());
+    Customer."Customer Discount Group" := '';
+    Customer.Modify();
+
+    SalesHeader := CreateSalesOrderWithAmount(Customer."No.", 500);
+
+    // [WHEN] Calculating discount in November
+    ActualDiscount := OrderDiscountMgr.CalculateDiscount(SalesHeader);
+
+    // [THEN] 5% seasonal discount is applied
+    Assert.AreEqual(5, ActualDiscount, 'Seasonal discount not applied in November');
+end;
+
+[Test]
+procedure TestNoSeasonalDiscountInJanuary()
+var
+    Customer: Record Customer;
+    SalesHeader: Record "Sales Header";
+    OrderDiscountMgr: Codeunit "Order Discount Manager";
+    ActualDiscount: Decimal;
+    CurrentMonth: Integer;
+begin
+    // [SCENARIO] No seasonal discount in non-holiday months
+
+    Initialize();
+
+    CurrentMonth := Date2DMY(Today, 2);
+    if CurrentMonth in [11, 12] then
+        exit; // Skip test if in seasonal period
+
+    // [GIVEN] Standard customer with small order
+    Customer.Get(LibrarySales.CreateCustomerNo());
+    Customer."Customer Discount Group" := '';
+    Customer.Modify();
+
+    SalesHeader := CreateSalesOrderWithAmount(Customer."No.", 500);
+
+    // [WHEN] Calculating discount outside seasonal period
+    ActualDiscount := OrderDiscountMgr.CalculateDiscount(SalesHeader);
+
+    // [THEN] No discount is applied
+    Assert.AreEqual(0, ActualDiscount, 'Unexpected discount outside seasonal period');
+end;
+
+// [RECOMMENDATION] Refactor GetSeasonalDiscount to accept date parameter
+// This would make testing much easier and more reliable:
+// local procedure GetSeasonalDiscount(CheckDate: Date): Decimal
+```
+
+### Step 8: Integration Test
+
+**Prompt**:
+
+```
+Create an integration test that tests the complete workflow:
+
+1. Create a new customer with VIP status
+2. Create a sales order for that customer
+3. Add multiple lines totaling over 10,000
+4. Calculate the discount
+5. Verify all discount types are correctly combined
+6. Verify the discount is applied to the sales header
+
+This test should verify the codeunit works correctly with real BC data and tables.
+```
+
+**Expected Result**:
+
+```al
+[Test]
+procedure TestCompleteDiscountWorkflow()
+var
+    Customer: Record Customer;
+    SalesHeader: Record "Sales Header";
+    SalesLine: Record "Sales Line";
+    Item: Record Item;
+    OrderDiscountMgr: Codeunit "Order Discount Manager";
+    ExpectedDiscount: Decimal;
+    ActualDiscount: Decimal;
+    CurrentMonth: Integer;
+begin
+    // [SCENARIO] Complete workflow of discount calculation and application
+    Initialize();
+
+    // [GIVEN] A VIP customer
+    Customer.Get(LibrarySales.CreateCustomerNo());
+    Customer."Customer Discount Group" := 'VIP';
+    Customer.Modify();
+
+    // [GIVEN] A sales order with multiple lines totaling 12,000
+    LibrarySales.CreateSalesHeader(SalesHeader, SalesHeader."Document Type"::Order, Customer."No.");
+
+    // Add three items
+    CreateItemAndSalesLine(SalesHeader, 5000);
+    CreateItemAndSalesLine(SalesHeader, 4000);
+    CreateItemAndSalesLine(SalesHeader, 3000);
+
+    // [GIVEN] Expected discount calculation:
+    // - VIP customer: 10%
+    // - Volume (>10000): 15%
+    // - Seasonal (if Nov/Dec): 5%
+    CurrentMonth := Date2DMY(Today, 2);
+    if CurrentMonth in [11, 12] then
+        ExpectedDiscount := 30  // 10 + 15 + 5
+    else
+        ExpectedDiscount := 25; // 10 + 15
+
+    // [WHEN] Calculating the discount
+    ActualDiscount := OrderDiscountMgr.CalculateDiscount(SalesHeader);
+
+    // [THEN] The correct combined discount is calculated
+    Assert.AreEqual(ExpectedDiscount, ActualDiscount,
+        'Complete discount calculation incorrect');
+
+    // [THEN] Verify order total is correct
+    SalesLine.SetRange("Document Type", SalesHeader."Document Type");
+    SalesLine.SetRange("Document No.", SalesHeader."No.");
+    SalesLine.CalcSums("Line Amount");
+    Assert.AreEqual(12000, SalesLine."Line Amount", 'Order total incorrect');
+end;
+
+local procedure CreateItemAndSalesLine(SalesHeader: Record "Sales Header"; Amount: Decimal)
+var
+    Item: Record Item;
+    SalesLine: Record "Sales Line";
+begin
+    Item."No." := LibraryUtility.GenerateRandomCode(Item.FieldNo("No."), Database::Item);
+    Item."Unit Price" := Amount;
+    Item.Insert();
+
+    LibrarySales.CreateSalesLine(SalesLine, SalesHeader, SalesLine.Type::Item, Item."No.", 1);
+    SalesLine.Validate("Unit Price", Amount);
+    SalesLine.Modify(true);
+end;
+```
+
+## Review Points: What to Check in Tests
+
+### ✅ Test Quality
+
+- [ ] Tests are independent (can run in any order)
+- [ ] Tests are repeatable (same result every time)
+- [ ] Tests have clear Given-When-Then structure
+- [ ] Test names clearly describe what is being tested
+- [ ] Assertions have descriptive error messages
+
+### ✅ Test Coverage
+
+- [ ] Happy path scenarios covered
+- [ ] Error cases tested
+- [ ] Edge cases and boundaries tested
+- [ ] All public procedures have tests
+- [ ] Integration scenarios tested
+
+### ✅ Test Maintainability
+
+- [ ] Helper methods reduce duplication
+- [ ] Test data creation is centralized
+- [ ] Tests are easy to understand
+- [ ] Tests don't depend on specific data
+- [ ] Setup and teardown properly implemented
+
+### ✅ Test Performance
+
+- [ ] Tests run quickly
+- [ ] Minimal database operations
+- [ ] Proper use of test isolation
+- [ ] No unnecessary waits or delays
+
+## Advanced Testing Patterns
+
+### Pattern 1: Test Fixtures
+
+**Prompt**:
+
+```
+Create a test fixture class for sales orders that provides:
+- Standard order (customer with no discounts, small amount)
+- VIP order (VIP customer, medium amount)
+- Large order (standard customer, large amount)
+- Complex order (VIP customer, large amount, multiple lines)
+
+These fixtures should be reusable across all tests.
+```
+
+### Pattern 2: Mock Objects
+
+**Prompt**:
+
+```
+The GetSeasonalDiscount procedure is hard to test because it depends on Today.
+
+Refactor the code to use dependency injection:
+1. Create an interface for date provider
+2. Inject the date provider into the codeunit
+3. Create a mock date provider for testing
+4. Show how to test with different dates
+```
+
+### Pattern 3: Test Data Builders
+
+**Prompt**:
+
+```
+Create a fluent test data builder for sales orders:
+
+SalesOrderBuilder
+  .WithCustomer(CustomerNo)
+  .WithVIPStatus()
+  .WithLine(ItemNo, Quantity, Price)
+  .WithTotalAmount(Amount)
+  .Build()
+
+This makes test data creation more readable and flexible.
+```
+
+## Best Practices for AI-Assisted Testing
+
+### 1. Start with Test Cases, Then Generate
+
+```
+Before generating test code, help me identify all test cases for this procedure:
+- What scenarios should be tested?
+- What are the edge cases?
+- What error conditions exist?
+- What are the boundary conditions?
+
+[Include procedure code]
+```
+
+### 2. Generate Tests in Batches
+
+```
+Generate tests for these three related procedures together so they share test helpers:
+- CalculateDiscount
+- ApplyDiscount
+- ValidateDiscount
+```
+
+### 3. Request Explanatory Comments
+
+```
+Generate the test with detailed comments explaining:
+- Why this test case is important
+- What could go wrong if this test didn't exist
+- Any gotchas or special considerations
+```
+
+### 4. Ask for Test Improvements
+
+```
+Review this test I wrote. Suggest improvements for:
+- Clarity and readability
+- Better assertions
+- Edge cases I might have missed
+- Ways to make it more maintainable
+```
+
+### 5. Generate Test Documentation
+
+```
+Create documentation for this test suite explaining:
+- What is being tested
+- Test coverage summary
+- How to run the tests
+- How to add new tests
+- Known limitations
+```
+
+## Common Testing Challenges
+
+### Challenge 1: Testing Private Methods
+
+**Problem**: Local procedures can't be tested directly
+
+**Solution**:
+
+```
+I need to test this local procedure. Options:
+1. Make it public (if appropriate)
+2. Test it indirectly through public procedures
+3. Extract to a separate testable codeunit
+
+Which approach is best for this scenario? [Include code]
+```
+
+### Challenge 2: Testing Database Operations
+
+**Problem**: Tests that modify database are slow and fragile
+
+**Solution**:
+
+```
+This codeunit performs database operations. Help me:
+1. Identify which operations need real database
+2. Which can be mocked or isolated
+3. Create a testing strategy that balances coverage and speed
+```
+
+### Challenge 3: Testing External Dependencies
+
+**Problem**: Code calls external services or APIs
+
+**Solution**:
+
+```
+This code calls an external API. Create:
+1. An interface for the API
+2. A mock implementation for testing
+3. Tests using the mock
+4. Integration tests for the real API (marked for manual runs)
+```
+
+## Practice Exercise
+
+Write comprehensive tests for this codeunit:
+
+```al
+codeunit 50200 "Credit Limit Checker"
+{
+    procedure CheckCreditLimit(CustomerNo: Code[20]; NewOrderAmount: Decimal): Boolean
+    var
+        Customer: Record Customer;
+        CustLedgerEntry: Record "Cust. Ledger Entry";
+        TotalOutstanding: Decimal;
+    begin
+        if not Customer.Get(CustomerNo) then
+            Error('Customer not found');
+
+        Customer.CalcFields("Balance (LCY)");
+        TotalOutstanding := Customer."Balance (LCY)" + NewOrderAmount;
+
+        if Customer."Credit Limit (LCY)" = 0 then
+            exit(true);
+
+        exit(TotalOutstanding <= Customer."Credit Limit (LCY)");
+    end;
+}
+```
+
+**Your Tasks**:
+
+1. List all test scenarios
+2. Create test codeunit structure
+3. Implement tests for:
+   - Customer not found
+   - No credit limit (unlimited)
+   - Within credit limit
+   - Exactly at credit limit
+   - Over credit limit
+   - Edge cases
+4. Add integration test
+5. Review and improve tests
+
+## Next Steps
+
+- Learn how [code review](../code-review) can verify test quality
+- See how [refactoring](../refactoring) benefits from good tests
+- Explore [documentation](../documentation) for test procedures

content/docs/patterns/no-series/index.md

@@ -10,6 +10,68 @@ _Created by Microsoft, Described by Jeremy Vyska (Spare Brained Ideas)_
 
 The "Number Series" system is used extensively to provide numbers to master records, documents, and other transactions through Microsoft Dynamics 365 Business Central.
 
+## Important: BC v24+ Modern Pattern (Updated 2024)
+
+**As of Business Central version 24.0 and later**, Microsoft deprecated the `NoSeriesManagement` codeunit in favor of the new `codeunit "No. Series"` with simplified methods.
+
+### Modern Implementation (BC v24+)
+
+**Variable declaration:**
+```al
+var
+    NoSeries: Codeunit "No. Series";
+```
+
+**OnInsert pattern (simplified):**
+```al
+trigger OnInsert()
+begin
+    if "No." = '' then begin
+        MySetup.Get();
+        MySetup.TestField("Document Nos.");
+        "No. Series" := MySetup."Document Nos.";
+        if NoSeries.AreRelated(MySetup."Document Nos.", xRec."No. Series") then
+            "No. Series" := xRec."No. Series";
+        "No." := NoSeries.GetNextNo("No. Series");
+    end;
+end;
+```
+
+**OnValidate pattern (same as before):**
+```al
+trigger OnValidate()
+begin
+    if "No." <> xRec."No." then begin
+        MySetup.Get();
+        NoSeries.TestManual(MySetup."Document Nos.");
+        "No. Series" := '';
+    end;
+end;
+```
+
+### Key Differences from Legacy Pattern
+
+| Legacy (NoSeriesManagement) | Modern (No. Series) |
+|----------------------------|---------------------|
+| `NoSeriesMgt.InitSeries(...)` - 5 parameters | `NoSeries.GetNextNo(...)` - 1-2 parameters |
+| `NoSeriesMgt.TestManual(...)` | `NoSeries.TestManual(...)` - Same method name |
+| `NoSeriesMgt.TryGetNextNo(...)` | `NoSeries.PeekNextNo(...)` - New name |
+| `NoSeriesMgt.SelectSeries(...)` | `NoSeries.AreRelated(...)` - Simplified API |
+| Complex parameter passing | Simplified, intuitive API |
+
+### Migration Strategy
+
+For **backward compatibility** (supporting both BC v23 and v24+):
+1. Use conditional compilation with `#if` directives based on platform version
+2. Check runtime platform version and branch logic accordingly
+3. Implement both patterns in separate procedures with version detection
+
+{{% alert title="Note" color="warning" %}}
+**The examples below reflect the LEGACY pattern** (NoSeriesManagement codeunit) for reference and historical context. For new development on BC v24+, use the modern `codeunit "No. Series"` pattern shown above.
+{{% /alert %}}
+
+---
+
 ## Description
 
 At the heart of things, the Number Series engine allows users to define structure for a sequential numeric or alphanumeric string (collectively referred to as a 'number series'), then assign that structure to different parts of the system.
@@ -283,4 +345,4 @@ For usage of number series, there is more information available on:
 - [Microsoft Docs: Create Number Series](https://docs.microsoft.com/en-us/dynamics365/business-central/ui-create-number-series)
 - [Microsoft Learn: Set up number series and trail codes](https://docs.microsoft.com/en-us/learn/modules/number-series-trail-codes-dynamics-365-business-central/)
 
-For more programming details, there is more information on [Microsoft Docs: Number Sequences in Business Central](https://docs.microsoft.com/en-us/dynamics365/business-central/dev-itpro/developer/devenv-number-sequences).
+For more programming details, there is more information on [Microsoft Docs: Number Sequences in Business Central](https://docs.microsoft.com/en-us/dynamics365/business-central/dev-itpro/developer/devenv-number-sequences).