Alexey Golub on Functional Architecture for Testable and Maintainable Applications

Speaker: Alexey Golub @Tyrrrz
Dependency absolution
Application as a pipeline

Who am I?
Open source developer
• https://github.com/Tyrrrz
• 6 active projects
• 4000 total stars
• 400k total downloads
Senior software developer
• Svitla Systems, Inc
• C#, ASP.NET Core, Docker, AWS
Interests
• C#, F#, JavaScript
• Functional programming
• Language design, parsing, DSLs
• Product design, photography

Best code is no code at all
Bad design decisions lead to writing more code in the long run

Domain modeling

Object-oriented approach
public class Ledger
{
public Guid Id { get; }
public decimal Balance { get; private set; }
public Ledger(Guid id, decimal initialBalance) { /* ... */ }
public void Debit(decimal amount) { /* ... */ }
public void Credit(decimal amount) { /* ... */ }
public static Ledger Create(decimal initialBalance = 0.0M) { /* ... */ }
public static Ledger Retrieve(Guid id) { /* ... */ }
}

public void Debit(decimal amount)
{
if (Balance < amount)
throw new InsufficientFundsException();
Balance -= amount;
Database.Save(this);
}
Business logic
Dependency

Object
Dependency

Object
Dependency
Object
Abstraction
Dependency
Mock

{
Balance -= amount;
ServiceLocator.GetService<IDatabase>().Save(this);
}

{
Balance -= amount;
ServiceLocator.GetService<IDatabase>().Save(this);
}
private readonly IDatabase _database;
/* ... */
{
Balance -= amount;
_database.Save(this);
}
Abstract dependency

Benefits of dependency injection
• Inversion of control
• Lifetime management
• Decoupled implementations
• Reduced module complexity
• Isolated testing

Layered architecture

Domain models
Data access
Services
System boundary

Layered/onion architecture
public class Ledger
{
public Guid Id { get; set; }
public decimal Amount { get; set; }
}
public interface ILedgerRepository
{
Task AddAsync(Ledger ledger);
Task UpdateAsync(Ledger ledger);
Task<Ledger> RetrieveAsync(Guid id);
}
public interface ILedgerService
{
Task<Ledger> CreateAsync(decimal initialBalance = 0.0M);
Task DebitAsync(Guid id, decimal amount);
Task CreditAsync(Guid id, decimal amount);
}

Ledger
LedgerRepository
LedgerService
LedgerController
System boundary (entry point)
Service layer
Data access layer
Domain model

Ledger
LedgerRepository
LedgerService
LedgerController
TransactionFee Counterparty
TransactionController
TransactionService
FeeService
Statement
StatementService
CounterpartyService
FeeRepository TransactionRepositoryCounterpartyRepository StatementRepository
ScheduledJob
NotificationService

Layers of issues

Hard to combine with OOD
• Existing paradigms became anti-patterns
• Encapsulation is gone
• Inheritance is disfavored
• Static classes & methods are “untestable”

Causational indirectness
• Hard to trace
• Hard to reason about
• Implicit dependencies & DI made us lazy

Leaky async
• Async stems from IO side-effects and leaks into business logic
• Unnecessary state machines impact performance
• Code becomes redundantly verbose

public class LedgerService : ILedgerService
{
private readonly ILedgerRepository _repository;
/* ... */
public async Task DebitAsync(Guid ledgerId, decimal amount)
{
var ledger = await _repository.GetByIdAsync(ledgerId);
if (ledger is null)
throw new EntityNotFoundException();
if (ledger.Balance < amount)
ledger.Balance -= amount;
await _repository.SaveChangesAsync();
}
}
Leaky async

public interface ILedgerService
{
Task<Ledger> CreateAsync(decimal initialBalance = 0.0M);
Task DebitAsync(Guid id, decimal amount);
Task CreditAsync(Guid id, decimal amount);
}
ILedgerService reveals the fact that LedgerService depends on ILedgerRepository

Obscured complexity
• Module complexity is reduced
• Total complexity is increased
• Assumptions between communicating modules

Mock-based testing
• Implementation-aware
• Very brittle
• Massive time sink

// Arrange
var transactionRepositoryMock = new Mock<ITransactionRepository>();
transactionRepositoryMock.Setup(x => x.GetAll())
.Returns(testData.AsQueryable());
var counterpartyServiceMock = new Mock<ICounterpartyService>();
counterpartyServiceMock.Setup(x => x.GetCounterpartyAsync(It.IsAny<Transaction>()))
.ReturnsAsync(testCounterparty);
var transactionService = new TransactionService(
transactionRepositoryMock.Object,
counterpartyServiceMock.Object
);
var transaction = new Transaction
{
// ...
}
// Act
await transactionService.ExecuteTransactionAsync(transaction);
// Assert
// ...
Implementation-aware

Autotelic abstractions
• Every object requires an explicit abstraction
• Abstractions are needed for the sole purpose of mocking
• Abstractions don’t try to encapsulate behavior
• Abstractions are owned by implementations instead of consumers

Abstraction is a great tool
and a terrible goal

Is OOP the wrong tool for
the job?

Functional architecture

ImpurePure

Side-effects
Data
transformation
Validating, parsing,
mapping, ordering,
filtering, projecting…
Reading request, writing
to DB, enqueuing
messages…

Pure functions

F(x)Data in Data out
Isolation
SQL

Stateless

var fees = _invoiceService.CalculateFees();
Can I make any assumptions about _invoiceService?

var fees = InvoiceLogic.CalculateFees(ledger, invoiceDate);
Dependencies are clear which makes the intent clear

Data-driven

private readonly CommonDbContext _dbContext;
/* ... */
public IEnumerable<Transaction> GetCompletedTransactions(Guid ledgerId)
{
return _dbContext.Transactions
.Where(t => t.LedgerId == ledgerId)
.Where(t => t.IsCompleted);
}
Data container

public static IEnumerable<Transaction> GetCompletedTransactions(
IEnumerable<Transaction> allTransactions, Guid ledgerId)
{
return allTransactions
.Where(t => t.LedgerId == ledgerId)
.Where(t => t.IsCompleted);
}

Deterministic

public static DateTimeOffset GetInvoiceDate(int day)
{
var instant = DateTimeOffset.Now;
var potentialInvoiceDate = instant.Day >= day
? instant.AddDays(day - instant.Day)
: instant.AddMonths(-1).AddDays(day - instant.Day);
if (potentialInvoiceDate.DayOfWeek == DayOfWeek.Saturday)
potentialInvoiceDate = potentialInvoiceDate.AddDays(-1);
else if (potentialInvoiceDate.DayOfWeek == DayOfWeek.Sunday)
return potentialInvoiceDate;
}
Non-deterministic

public static DateTimeOffset GetInvoiceDate(DateTimeOffset instant, int day)
{
var potentialInvoiceDate = instant.Day >= day
? instant.AddDays(day - instant.Day)
: instant.AddMonths(-1).AddDays(day - instant.Day);
if (potentialInvoiceDate.DayOfWeek == DayOfWeek.Saturday)
else if (potentialInvoiceDate.DayOfWeek == DayOfWeek.Sunday)
return potentialInvoiceDate;
}

Inherently testable

var result = InvoiceLogic.GetInvoiceDate(instant, day);

private static IEnumerable<TestCaseData> GetTestCases()
{
yield return new TestCaseData(
new DateTimeOffset(2019, 12, 05, 00, 00, 00, TimeSpan.Zero),
20,
new DateTimeOffset(2019, 11, 20, 00, 00, 00, TimeSpan.Zero)
);
yield return new TestCaseData(
new DateTimeOffset(2019, 12, 25, 00, 00, 00, TimeSpan.Zero),
22,
new DateTimeOffset(2019, 12, 20, 00, 00, 00, TimeSpan.Zero)
);
}
[Test]
[TestCaseSource(nameof(GetTestCases))]
public void GetInvoiceDate_Test(DateTimeOffset instant, int day, DateTimeOffset expectedResult)
{
// Act
var actualResult = InvoiceLogic.GetInvoiceDate(instant, day);
// Assert
Assert.That(actualResult, Is.EqualTo(expectedResult));
}

Pure-impure segregation

public static class Program
{
public static void Main(string[] args)
{
var max = int.Parse(Console.ReadLine());
for (var i = 1; i <= max; i++)
{
if (i % 2 == 0)
Console.WriteLine(i);
}
}
}
Logic
Side-effects

{
public static IEnumerable<int> EnumerateEvenNumbers(int max)
=> Enumerable.Range(1, max).Where(i => i % 2 == 0);
{
var max = int.Parse(Console.ReadLine());
foreach (var number in EnumerateEvenNumbers(max))
Console.WriteLine(number);
}
}
Logic
Side-effects

{
public static TOut Pipe<TIn, TOut>(this TIn in, Func<TIn, TOut> transform)
=> transform(in);
public static IEnumerable<int> EnumerateEvenNumbers(int max)
=> Enumerable.Range(1, max).Where(i => i % 2 == 0);
{
Console.ReadLine()
.Pipe(int.Parse)
.Pipe(EnumerateEvenNumbers)
.ToList()
.ForEach(Console.WriteLine);
}
}

private readonly ICounterpartyRepository _counterpartyRepository;
private readonly ILogger _logger;
/* ... */
public async Task<Counterparty> GetCounterpartyAsync(Transaction transaction)
{
var counterparties = await _counterpartyRepository.GetAll().ToArrayAsync();
foreach (var counterparty in counterparties)
{
if (!counterparty.SupportedTransactionTypes.Contains(transaction.Type))
continue;
if (!counterparty.SupportedCurrencies.Contains(transaction.Currency))
continue;
_logger.LogInformation($"Transaction {transaction.Id} routed to '{counterparty}'");
return counterparty;
}
throw new CounterpartyNotFoundException("No counterparty found to execute this transaction.");
}

public static async Task<Counterparty> GetCounterpartyAsync(
ICounterpartyRepository counterpartyRepository, ILogger logger, Transaction transaction)
{
var counterparties = await counterpartyRepository.GetAll().ToArrayAsync();
{
continue;
continue;
logger.LogInformation($"Transaction {transaction.Id} routed to '{counterparty}'");
}
}

public delegate Task<IReadOnlyList<Counterparty>> AsyncCounterpartyResolver();
public delegate void LogHandler(string message);
public static async Task<Counterparty> GetCounterpartyAsync(
AsyncCounterpartyResolver getCounterpartiesAsync,
LogHandler log,
Transaction transaction)
{
var counterparties = await getCounterpartiesAsync();
{
continue;
continue;
log($"Transaction {transaction.Id} routed to '{counterparty}'");
}
}

public static Counterparty GetCounterparty(
IReadOnlyList<Counterparty> counterparties, LogHandler log, Transaction transaction)
{
{
continue;
continue;
log($"Transaction {transaction.Id} routed to '{counterparty}'");
}
}

public static Counterparty GetCounterparty(
IReadOnlyList<Counterparty> counterparties, Transaction transaction)
{
{
continue;
continue;
}
}

public static Counterparty? TryGetCounterparty(
IReadOnlyList<Counterparty> counterparties, Transaction transaction)
{
{
continue;
continue;
}
return null;
}

public static IEnumerable<Counterparty> GetAvailableCounterparties(
IEnumerable<Counterparty> counterparties, Transaction transaction)
{
return counterparties
.Where(c => c.SupportedTransactionTypes.Contains(transaction.Type))
.Where(c => c.SupportedCurrencies.Contains(transaction.Currency))
}

private readonly ICounterpartyRepository _counterpartyRepository;
private readonly ILogger _logger;
/* ... */
public async Task<Counterparty> GetCounterpartyAsync(Transaction transaction)
{
var counterparties = await _counterpartyRepository.GetAll().ToArrayAsync();
var counterparty = CounterpartyLogic
.GetAvailableCounterparties(counterparties, transaction)
.FirstOrDefault();
return counterparty ??
}

[HttpGet]
public async Task<IActionResult> GetCounterparty(Transaction transaction)
{
var counterparties = await _dbContext.Counterparties.ToArrayAsync();
var counterparty = CounterpartyLogic
.GetAvailableCounterparties(counterparties, transactions)
.FirstOrDefault();
if (counterparty is null)
return NotFound("No counterparty found to execute this transaction.");
return Ok(counterparty);
}

Controller

DbContext
Controller
Pull
data
Filter
counterparties
Select
counterparty
Calculate
fee
Deduct
balance
Push
data
… …

Pure-impure segregation principle
• Impure functions can call pure functions
• Pure functions cannot call impure functions
• Impure functions should be pushed outwards
• Work towards maximum purity

Pure layer
Impure layer
System boundary

Testing

Unit tests
Functional tests
Integration
tests

Functional tests
Unit tests
Integration
tests

Functional tests
Logic tests
Integration
tests

Recipe for reliable tests
1. Cover functional requirements (Functional tests)
2. Cover business logic (Logic tests)
3. Cover system-wide integration (Integration tests)

Functional tests shouldn’t be difficult
• TestServer (ASP.NET Core)
• WebApplicationFactory (ASP.NET Core)
• Browser (NancyFx)
• TestConsole (System.CommandLine)
• VirtualConsole (CliFx)
• Docker (*anything*)

Summary
• Avoid introducing dependencies
• Avoid meaningless abstractions
• Avoid tests that rely on mocks
• Avoid cargo cult programming
• Prefer pure-impure segregation
• Prefer pure functions for business logic
• Prefer pipelines to hierarchies
• Prefer functional tests

Consider checking out
• Functional architecture by Mark Seemann
• Async injection by Mark Seemann
• Test-induced damage by David Heinemeier Hansson
• TDD is dead, long live testing by David Heinemeier Hansson
• Functional principles for OOD by Jessica Kerr
• Railway-oriented programming by Scott Wlaschin

Thank you!

Alexey Golub on Functional Architecture for Testable and Maintainable Applications

Recommended

Recommended

More Related Content

What's hot

What's hot (20)

Similar to Alexey Golub on Functional Architecture for Testable and Maintainable Applications

Similar to Alexey Golub on Functional Architecture for Testable and Maintainable Applications (20)

Recently uploaded

Recently uploaded (20)

Alexey Golub on Functional Architecture for Testable and Maintainable Applications