Sean Wallis - Blog

The Portable Document Format (PDF) is used throughout the web and beyond. Created in the 1990s by Adobe, it provides a platform independent method of accessing documents across a wide range of devices. Regardless of software, hardware and operating system: PDF layouts, text, fonts, colours and graphics should all remain the same. Which all sounds very accessible, but is it?

Unfortunately PDFs are not by default accessible to everyone, yet with the right content and a tagged structure they can be greatly improved if opened with the correct software.

Whether you want to boost your search engine performance and reach the widest possible audience, or just stay ahead of the game when it comes to legal compliance, then accessibility should be important to you. Thankfully, there are already guidelines for this.

The Web Content Accessibility Guidelines (WCAG) are accessibility recommendations developed by The Web Accessibility Initiative (WAI), which is part of The World Wide Web Consortium (W3C). When they’re not too busy creating more acronyms, WCAG aim to provide a single shared standard, ensuring that users with different disabilities are able to access and interact with content as much as possible without restrictions.

According to the World Health Organisation around 1.3 billion people live with some form of vision impairment. Of those, 217 million have moderate to severe vision impairment, and 36 million people are blind. Whilst those most severe cases are low proportionally, they are not small numbers. Within the context of developing for the web, they are people that should not be forgotten. They too should have the independence to navigate content, shop online and engage with the world.

We start with an innocent looking changelog.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

---
title: Changelog
status: ready # draft, ready
---

All notable changes to this project will be documented in this file.<br>
The format is based on [Keep a Changelog](http://keepachangelog.com)

## [2.0.0] - Unreleased
### Added
- _Component [footer]({{ componentPath '@footer' }})_:
  Added copyright to the footer

### Changed
- _Component [accordion]({{ componentPath '@accordion' }})_:
  Replaced title divs with header elements
- _Component [textarea]({{ componentPath '@textarea' }})_:
  Label font made bold

### Removed
- _Component [sidenav]({{ componentPath '@sidenav' }})_:
  removed class `my-class-1` from `ul` element

## [1.0.0] - 2018-04
### Added
- _Component [carousel]({{ componentPath '@carousel' }})_:
  A header to the carousel component

Harmless right? OK, so the above is a simplified version of the real thing, but we get the structure. It’s based upon the Keep a Changelog format; so for each release we have Added, Changed and Removed headings where applicable. It’s also more than just a changelog. It gets built into a webpage using Fractal, which in turn resolves the component path links we see above on build.

Running automated acceptance tests are an excellent way to verify your application does exactly what it is intended to do. Each time you make changes to your application, your previous tests will always be there to give assurance that new functionality does not break anything.

In this post we’ll look at how we can use Mink and Behat to simulate the interaction between a browser session and a simple service api.

Sometimes when unit testing PHP code, we run into things that are difficult to mock. This post will introduce how you can mock built-in php functions such as time() and mt_rand().

Mocking time()

Let’s take the below example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

namespace Example\Namespace;

function displayGreeting()
{
    $time = time();
    $hour = date("g", $time);
    $meridiem = date("A", $time);
    if ($meridiem == "AM") {
        return 'Good Morning';
    }
    if ($hour <= 6 || $hour == 12) {
        return 'Good Afternoon';
    }
    return 'Good Evening';
}

In order to fully test our display greeting function we need to be able to manipulate the time element, without having to change any system settings.