The document discusses the principles and advantages of hexagonal (also known as ports and adapters) architecture in Magento projects. It promotes decoupling the core domain logic from infrastructure dependencies to improve testability. The core focuses only on the domain while adapters implement interfaces to interact with external systems. This allows framework-agnostic testing of the core and integration tests of adapters. Implementing hexagonal architecture can help create complex, long-lasting, and multi-platform code by separating concerns between the core and infrastructure.

1. Principles & Advantages
of Hexagonal Architecture
on Magento
June 10/11 2021  Virtual Conference
Alessandro Ronchi
COO  Bitbull

2. Principles & Advantages of Hexagonal Architecture on Magento
Testing is hard
it is even harder on Magento

3. Principles & Advantages of Hexagonal Architecture on Magento
There must be a way
to simplify testing

4. Principles & Advantages of Hexagonal Architecture on Magento
to the rescue
Hexagonal architecture

5. Principles & Advantages of Hexagonal Architecture on Magento
Decoupling
Focus on the domain
Focus on testability
Advantages

6. Principles & Advantages of Hexagonal Architecture on Magento
Team mentor at Bitbull
Passionate about Software Design
Magento Master & Maintainer
About me
@aleron75

7. Principles & Advantages of Hexagonal Architecture on Magento
a different way of layering components
Hexagonal architecture

8. Principles & Advantages of Hexagonal Architecture on Magento
Decoupling
Core vs Infrastructure

9. CORE
CODE
DOES NOT DEPEND ON
EXTERNAL SYSTEMS
INFRASTRUCTURE
CODE
DEPENDS ON
EXTERNAL SYSTEMS

10. INFRASTRUCTURE
CORE
R/W
MODEL
WEB
CONTROLLER
USES
R/W

11. CORE
CODE
DEFINES & DEPENDS ON
ABSTRACTIONS
INFRASTRUCTURE
CODE
IMPLEMENTS
ABSTRACTIONS

12. CORE
CODE
DEFINES & DEPENDS ON
ABSTRACTIONS
INFRASTRUCTURE
CODE
IMPLEMENTS
ABSTRACTIONS
MYSQL REPOSITORY
<REPOSITORY>
IMPLEMENTED BY

13. CORE
CODE
DOES NOT DEPEND ON
CONTEXT
INFRASTRUCTURE
CODE
DEPENDS ON
CONTEXT
WEB CONTROLLER
SERVICE
USED BY

14. CORE
CODE
DOES NOT DEPEND ON
CONTEXT
INFRASTRUCTURE
CODE
DEPENDS ON
CONTEXT
CLI COMMAND
SERVICE
USED BY

15. INFRASTRUCTURE
CORE
SERVICE
MYSQL
REPOSITORY
<REPOSITORY>
WEB
CONTROLLER
USES
IMPLEMENTED BY
USES
USES
R/W
CLI
COMMAND
USES

17. APPLICATION
CARD REPOSITORY
CARD
CONTROLLER
USES
USES
R/W

18. class Save extends Action implements HttpPostActionInterface
{
// ...
public function execute()
{
$redirectResult =
$this->resultFactory->create(ResultFactory::TYPE_REDIRECT);
$cardNumber = $this->getRequest()->getParam('card_number');
$customerId = (int)$this->currentCustomer->getCustomerId();
// validation and error handling...
$card = $this->cardFactory->create();
$card->setData([
‘card_number’ => $cardNumber,
‘customer_id’ => $customerId,
]);
$this->cardRepository->save($card);
return $redirectResult->setPath('loyalty/card/index');
}
}

19. class Save extends Action implements HttpPostActionInterface
{
// ...
public function execute()
{
$redirectResult =
$this->resultFactory->create(ResultFactory::TYPE_REDIRECT);
$cardNumber = $this->getRequest()->getParam('card_number');
$customerId = (int)$this->currentCustomer->getCustomerId();
// validation and error handling...
$command = new RegisterCardCommand($customerId, $cardNumber);
$this->application->registerCard($command);
return $redirectResult->setPath('loyalty/card/index');
}
}

20. class Save extends Action implements HttpPostActionInterface
{
// ...
public function execute() {
// ...
$this->application->registerCard($command); // framework-agnostic
// ...
}
}
class Save extends Action implements HttpPostActionInterface
{
// ...
public function execute() {
// ...
$this->cardRepository->save($card); // framework-coupled
// ...
}
}
vs

21. CORE
CODE
- FRAMEWORK: AGNOSTIC
- CHANGES: MANAGED
INFRASTRUCTURE
CODE
- FRAMEWORK: BASED ON IT
- CHANGES: UNPREDICTABLE

22. Principles & Advantages of Hexagonal Architecture on Magento
a better name: Ports & Adapters
Hexagonal architecture

23. PORT
- WHAT OUR CORE CAN DO
- INTENT OF COMMUNICATION
ADAPTER
...

24. INFRASTRUCTURE
CORE
SERVICE
MYSQL
REPOSITORY
<REPOSITORY>
WEB
CONTROLLER
USES
IMPLEMENTED BY
USES
USES
R/W

25. INFRASTRUCTURE
CORE
PORT
MYSQL
REPOSITORY
<PORT>
WEB
CONTROLLER
USES
IMPLEMENTED BY
USES
USES
R/W

26. PORT
- INCOMING COMMUNICATION
- OUTGOING COMMUNICATION
ADAPTER
...

27. INFRASTRUCTURE
CORE
INCOMING PORT
MYSQL
REPOSITORY
<OUTGOING PORT>
WEB
CONTROLLER
USES
IMPLEMENTED BY
USES
USES
R/W

28. PORT
...
ADAPTER
- USES INCOMING PORTS
- IMPLEMENTS OUTGOING PORTS

29. INFRASTRUCTURE
CORE
INCOMING PORT
MYSQL
REPOSITORY
<OUTGOING PORT>
WEB
CONTROLLER
USES
IMPLEMENTED BY
USES
USES
R/W

30. INFRASTRUCTURE
CORE
INCOMING PORT
OUTGOING
ADAPTER
<OUTGOING PORT>
INCOMING
ADAPTER
USES
IMPLEMENTED BY
USES
USES
R/W

31. Principles & Advantages of Hexagonal Architecture on Magento
Focus on the domain
the CORE of our application

32. INFRASTRUCTURE
CORE

35. YOU NAME IT

36. Principles & Advantages of Hexagonal Architecture on Magento
Focus on testability
with framework-agnostic tests

38. USE-CASE TESTS
UNIT TESTS

39. USE-CASE TESTS
UNIT TESTS
Registration
✔ The customer can register an unregistered card
✔ The customer can’t register already registered card
✔ The customer can’t register more than one card
✔ The customer can delete a registered card
OK (4 tests)

40. USE-CASE TESTS
UNIT TESTS
IN-MEMORY
REPOSITORY
FAKE OBJECT USED
JUST FOR TESTING

41. USE-CASE TESTS
UNIT TESTS
Card Number
✔ It accepts ten digits
✔ It accepts all zeroes
✔ It doesn’t accept an empty string
✔ It doesn’t accept less than ten digits
✔ It doesn’t accept more than ten digits
✔ It doesn’t accept invalid chars
OK (6 tests)

42. USE-CASE TESTS
UNIT TESTS
NO EXTERNAL
DEPENDENCIES
NO NEED TO USE
MOCK OBJECTS

43. Principles & Advantages of Hexagonal Architecture on Magento
Test Infrastructure
with integration adapter tests

44. USE-CASE TESTS
UNIT TESTS

45. USE-CASE TESTS
UNIT TESTS
MYSQL
REPOSITORY
WEB
CONTROLLER
ADAPTER TESTS
ADAPTER TESTS

46. Card Controller
✔ It calls Application service getCardByCustomer()
✔ It calls Application service registerCard()
✔ It calls Application service deleteCardByCustomer()
OK (3 tests)
INCOMING TESTS
OUTGOING TESTS

47. INCOMING TESTS
OUTGOING TESTS
JUST VERIFY THAT AN INCOMING
ADAPTER CALLS THE PROPER SERVICE
CORE
USE APPLICATION
MOCK

48. Card Repository
✔ It can save a card and load it by its number
✔ It can save a card and load it by its customer
✔ It can delete a card by its customer
OK (3 tests)
INCOMING TESTS
OUTGOING TESTS

49. INCOMING TESTS
OUTGOING TESTS
JUST VERIFY THAT AN OUTGOING
ADAPTER PROPERLY HANDLES I/O

50. Principles & Advantages of Hexagonal Architecture on Magento
Increase confidence
with functional end-to-end tests

51. END-TO-END TESTS

52. UNIT TESTS
ADAPTER TESTS
E2E TESTS
USE-CASE TESTS
MFTF
Codeception
cypress.io
DOMAIN
LOGIC
I/O
APPLICATION

53. ddd/
└─ loyalty/
├─ src/
│ ├─ Application/
│ ├─ Controller/
│ ├─ Domain/
│ ├─ etc/
│ ├─ Model/
│ ├─ view/
│ └─ ViewModel/
├─ test/
│ ├─ Adapter/
│ ├─ Unit/
│ └─ UseCase/
├─ composer.json
└─ registration.php
CORE

54. Principles & Advantages of Hexagonal Architecture on Magento
Complex logic
Long-lasting code
Multi-platform code
When it is worth

55. Principles & Advantages of Hexagonal Architecture on Magento
Core hacks or fixes
Short-term code
Platform-specific code
When it is not worth

56. Principles & Advantages of Hexagonal Architecture on Magento
Split Core/Infrastructure
Use own abstractions
Apply a Testing Strategy
Takeaways

57. Principles & Advantages of Hexagonal Architecture on Magento
http://bit.ly/ddd-loyalty
The project

58. Principles & Advantages of Hexagonal Architecture on Magento
Inspired by

59. Principles & Advantages of Hexagonal Architecture on Magento
With a special discount
https://bit.ly/mn-awaa
The book

60. Principles & Advantages of Hexagonal Architecture on Magento
Thank you!
Questions: @aleron75

61. June 10/11 2021  Virtual Conference