We know we should be testing our code but what are the benefits of testing? Assurances that we can rapidly make changes to the code and ensure functionality is still kept intact. Well, what if there was more than just code security that practising testing could give us. I believe that by thinking about Objects and going back to the fundamentals of OOP ( Object Orientated Programming ) and thinking about how objects can **communicate** with each other we can design better applications adhering to **SRP** ( Single responsibility Principle ), **SOLID** and **DRY** and still retain a well tested and more verbosely documented system. By exploring concepts from OOP, DDD, BDD and TDD I will show that we can extract business domain code and encapsulate this into meaningful objects that are more testable, maintainable and showcase best OOP practices.

2. Hello World
@Jcowie
Magento ECG
Mage-Casts
Github: Jamescowie

3. Background on OOP
Insight into my thinking
Insight into my workflow
A fun 30 mins
Objectively

4. Object Oriented Programming

6. Messaging

7. Principles of GOOD software

9. SOLID
Uncle Bob Martin

10. Single Responsibility Principle
A class should have one and only
one reason to change, meaning
that a class should have only one
job.

11. Open Closed
Objects or entities should be open
for extension, but closed for
modification.

12. /**
* @api
*/
interface ProductRepositoryInterface
{
……
}

13. <preference
for="MagentoCatalogApiProductRepositoryInterface"
type="MagentoCatalogModelProductRepository”
/>

14. Interface Segregation Principle
A client should never be forced to
implement an interface that it
doesn’t use or clients shouldn’t be
forced to depend on methods they
do not use.

15. Dependency Inversion Principle
Entities must depend on
abstractions not on concretions. It
states that the high level module
must not depend on the low level
module, but they should depend
on abstractions.

16. /**
* @api
*/
interface ProductRepositoryInterface
{
……
}

17. <preference
for="MagentoCatalogApiProductRepositoryInterface"
type="MagentoCatalogModelProductRepository”
/>

18. I

19. A framework is just one of the tools
to help you developer “Better” and
“faster” - Symfony documentation

20. Convenient code Maintainable code

21. Convenient code Maintainable code
Coupled code
Mixed responsibility
Bound to framework
Harder to test

22. Convenient code Maintainable code
Coupled code
Mixed responsibility
Bound to framework
Harder to test
Decoupled code
Separated domain
Framework agnostic
Easier to test

23. public function execute()
{
if ($this->_request->getParam(MagentoFrameworkAppActionInterface::PARAM_NAME_URL_ENCODED)) {
return $this->resultRedirectFactory->create()->setUrl($this->_redirect->getRedirectUrl());
}
$category = $this->_initCategory();
if ($category) {
$this->layerResolver->create(Resolver::CATALOG_LAYER_CATEGORY);
$settings = $this->_catalogDesign->getDesignSettings($category);
// apply custom design
if ($settings->getCustomDesign()) {
$this->_catalogDesign->applyCustomDesign($settings->getCustomDesign());
}
$this->_catalogSession->setLastViewedCategoryId($category->getId());
…..
}
Magento can be convenient

24. class Index extends MagentoFrameworkAppActionAction

25. /** @var MagentoFrameworkViewResultPageFactory */
protected $resultPageFactory;
public function __construct(
MagentoFrameworkAppActionContext $context,
MagentoFrameworkViewResultPageFactory $resultPageFactory
) {
$this->resultPageFactory = $resultPageFactory;
parent::__construct($context);
}

26. Large number of dependencies
MagentoFrameworkAppActionContext $context,
MagentoFrameworkViewResultPageFactory $resultPageFactory
MagentoFrameworkRegistry $coreRegistry,
MagentoStoreModelStoreManagerInterface $storeManager,
CategoryRepositoryInterface $categoryRepository

27. Unit testing becomes hard

28. The “convenient” controller requires
more Integration Tests

29. Potential code smell

30. Lets see and Example

31. protected function configure()
{
$this->setName('generate:showcaseproducefeed');
$this->setDescription('Generate a produce feed of showcase products in json');
parent::configure();
}

32. protected function execute(InputInterface $input, OutputInterface $output)
{
$product = $this->products->get('24-MB01');
$writer = $this->filesystem->getDirectoryWrite('var');
$file = $writer->openFile('showcase.json', 'w');
try {
$file->lock();
try {
$file->write(json_encode(['product_name' => $product->getName(),
'product_price' => $product->getPrice()
]));
} finally {
$file->unlock();
}
} finally {
$file->close();
}
$output->writeln("Feed Generated");
}

33. Can we add XML feed generation

34. protected function execute(InputInterface $input, OutputInterface $output)
{
$product = $this->products->get('24-MB01');
$writer = $this->filesystem->getDirectoryWrite('var');
$file = $writer->openFile('showcase.json', 'w');
$xmlFile = $writer->openFile('showcase.xml', 'w');
try {
$file->lock();
try {
$file->write(json_encode(['product_name' => $product->getName(),
'product_price' => $product->getPrice()
]));
$showcaseXML = new SimpleXMLElement("<showcase></showcase>");
$showcaseXML->addAttribute('showcase-products', 'today');
$showcaseAttributes = $showcaseXML->addChild($product->getName());
$showcaseAttributes->addAttribute('price', $product->getPrice());
$xmlFile->write($showcaseXML->asXML());
} finally {
$file->unlock();
}…
$output->writeln("Feed Generated");
}

35. Our class had reason to change

36. How can we test this ?

37. public function __construct(
MagentoCatalogApiProductRepositoryInterface $productRepository,
MagentoFrameworkAppState $state,
MagentoFrameworkFilesystem $filesystem
) {
$state->setAreaCode('frontend');
$this->products = $productRepository;
$this->filesystem = $filesystem;
parent::__construct();
}
$showcaseXML = new SimpleXMLElement("<showcase></showcase>");

38. Scenario: Products are presented in JSON file
Given The generate command exists
When I run the generate command
Then I should see a JSON file created

39. use BehatBehatContextContext;
use SymfonyComponentProcessProcess;
use SymfonyComponentFilesystemFilesystem;

40. class FeatureContext implements Context
{
private $output;
private $filesystem;
public function __construct()
{
$this->filesystem = new Filesystem();
}
}

41. /**
* @Given The generate command exists
*/
public function theGenerateCommandExists()
{
return true;
}

42. /**
* @When I run the generate command
*/
public function iRunTheGenerateCommand()
{
$process = new Process("php " . getcwd()
. "/../../../generate:showcaseproducefeed");
$process->run();
$this->output = $process->getOutput();
}

43. /**
* @Then I should see a JSON file created
*/
public function iShouldSeeAJsonFileCreated()
{
expect(file_exists(__dir__ .
'/../../../../../../var/showcase.json'))->toBe(true);
}

44. Tests Pass

46. Scenario: Products are presented in XML file
Given The generate command exists
When I run the generate command
Then I should see a XML file created

47. Tests Fail

49. We could add this into the command buuuut.

50. Open Closed Principle

51. <?php
namespace TitansShowcaseApi;
interface BuilderInterface
{
public function build($data);
}

52. Create a scenario for extraction

53. Scenario: Class file does return json
When I call the JSONBuilder class
Then I should be returned a json string

54. public function __construct()
{
$this->builder =
new TitansShowcaseCommandsBuildersJsonBuilder();
}

55. /**
* @When I call the JSONBuilder class
*/
public function iCallTheJsonbuilderClass()
{
$this->output = $this->builder->build(['name' => 'james']);
}
/**
* @Then I should be returned a json string
*/
public function iShouldBeReturnedAJsonString()
{
expect($this->output)->toBe(json_encode(['name' => 'james']));
}

56. <?php
namespace TitansShowcaseCommandsBuilders;
class JsonBuilder implements
TitansShowcaseApiBuilderInterface
{
public function build($data)
{
return json_encode($data);
}
}

57. <?php
namespace TitansShowcaseCommandsBuilders;
class JsonBuilder implements TitansShowcaseApiBuilderInterface
{
public function build($data)
{
return json_encode($data);
}
}

58. <?php
namespace TitansShowcaseCommandsBuilders;
class XmlBuilder implements TitansShowcaseApiBuilderInterface
{
public function build($data)
{
return ….
}
}

59. public function __construct(
TitansShowcaseCommandsBuildersJsonBuilder $jsonBuilder
) {
$this->jsonBuilder = $jsonBuilder;
parent::__construct();
}

60. protected function execute(InputInterface $input, OutputInterface
$output)
{
$product = $this->products->get('24-MB01');
$this->writer->write(
'showcase.json',
$this->jsonBuilder->build(
['product_name' => $product->getName()]
)
);
}

61. Command Class
Builder Class
Sends Message

62. Command Class Responsibility for handling the command

63. JSON Builder Class Responsibility Building JSON based on a message
Value Object.

64. Command Class
Builder Class
Integration Tests
Framework code
Unit Tests
Library code

65. What are the benefits ?
We now pass messages between objects
We are testing to some level using Behat
We have clear Objects
We use Value Objects