I regularly bump into tasks that are…
1. tedious, if done manually
2. not done often enough, unless automated
3. still not done often enough, unless running them is automated, too.

In the workshop we’ll combine some Ruby tools to remedy this situation. In particular the workshop will cover:
1. Writing a simple Ruby program that does something useful, e.g. turn a markdown file into HTML
2. Wrapping that in a Rake task
3. Automate running the task

Knowing how to do this is useful, not only for projects using Ruby as their primary language, but can be handy in all projects.

What is expected:
1. Some Ruby knowledge; you don’t have to be an expert or anything like that.
2. A notebook (or tablet) with an internet connection & Ruby installed. Cool if you’re using RVM, rbenv or @chruby or similar
3. Mac OS X, BSD; Linux & friends are fine, Windows may be a bit problematic

In this hands on session, you will be taking part in various exercises to explore the pros and cons of the different types of pairing, when they are most suitable, and how you can take this away and starting applying it to your day-to-day work in software development.

The session will include:

• Jenga
• Marshmellows
• Lego
• Spaghetti

No really; it'll all become clear on the day.

There are no prerequisites

Wouldn’t it be wonderful if our tests could download a virtual image that booted in seconds and allowed us to run our tests against browsers that we don’t have installed on our local machines?
Wouldn’t it be great is we could remove the pain of setting up a selenium grid?

This workshop will have a look at how we can use docker to help mitigate some of that pain. The phases will be:

• Basic introduction to docker.
• Getting it up and running on everybody machines.
• Running tests against docker images.
• Automating the process of downloading and bringing up docker images with maven.
• A look at what this means to Selenium Grids.

There will also be a look at where docker is going and how it can continue to help us in the future.

Attendee prerequisites

• Java JDK 7+
• Maven 3
• IntelliJ IDEA
• Vagrant
• VirtualBox
• Docker
• Boot2Docker
• The code at https://github.com/Ardesco/Selenium-Maven-Template checked out and running.

Creativity stems creativity

In today’s development culture, frameworks such as BDD, TDD and techniques such as the 3 Amigos have a huge emphasis on “building the right thing”, where teams have the chance to discover ways to build (and test) their systems, collaboratively with the ultimate outcome that they have built the right solution for their users. But with collaboration and conversations comes the importance of clarity!

In our workshop, participants will get a hands on experience in learning about how creativity can really help software development and developing clarity when it comes to understand what we should be building. A Scrum approach will be incorporated throughout the workshop, which is split into 2 parts:

Part 1: A Planning meeting - Using sketch notes

The Objective:
To discuss, refine, analyse and design software requirements for a system using sketch notes.

The Questions:
What is sketch noting?
How do we sketch note?
What are the benefits of using the technique?

The Creative Part
We’ll then do some hands on sketch noting based on our interpretations of software requirements.

Part 2: A two hour sprint - Using Mind Maps

The Objective:
To build up story details and exploratory test your system using mind maps.

The Questions:
What are mind maps?
Why are they powerful?
How can you use the technique?
What is a great mind mapping software?

The Creative Part
We’ll then get hands on with doing some Paired Exploratory Testing, utilising mind maps to record our exploration, investigations and discoveries and test heuristics.

This workshop will be highly interactive and will require that you bring a laptop or suitable tablet device.

Prerequisites
Attendees will need to use their own laptops to either install LoadRunner locally or access Trust IV cloud-based servers via RDP.

In this session, John Howley and Chris Lucas from Trust IV in Manchester will help would-be performance testers get started with LoadRunner. This introduction to performance testing will explain the basic principles of performance testing and give attendees the opportunity to use HP LoadRunner in a controlled environment.

Topics Covered:

1.What is performance testing?
Where performance testing fits in the SDLC.
The benefits of test automation and discussion comparing functional and performance testing.
Introduction to performance test tool architecture.

2.Why performance test?

Infrastructure validation.
Quantifying risk.
Quantitative analysis, application performance under load, impact of changes, application capacity and break points.

3.What performance testing can do for us.

Identify application bottlenecks, scalability issues.
Important to clearly define the objectives of performance testing.

4.When should we performance test?

The simple answer is at all stages of the SDLC.
We’ll discuss the pros and cons of testing before your application is finished (shift-left) as well as introducing techniques and tools that help you to start testing earlier.

5.Introduction to more advanced techniques

Virtualisation (services, data and networks).
StormRunner, Performance Center and the new LoadRunner Web Controller.
Application performance monitoring and comparisons with production.

6.Performance Testing terminology

vUsers, Pacing, Think Time, Scripts and Scenarios.
Application protocols.
LoadRunner components VUGEN, Controller, Analysis, Load Generators, MoFW and MI Listener

7.Hands-on Session (laptops will be required)

All attendees will get access to a “LoadRunner in the Cloud” machine for the duration of the session, alternatively they could perform a full installation of LoadRunner Community Edition on their laptops prior to the session.

Attendees will be given access to a shopping cart application based on the popular Magento platform. This will give them experience in creating test scripts against a real-world application, rather than a “canned demo”.

Users who are less experienced will be provided with working scripts so that they can familiarise themselves with the process of running performance tests even if they have no interest in test scripting.

Topics covered:

a. HTTP vs TruClient recording

b. Error handling in test scripts

c. Using external code in LoadRunner (e.g. from GitHub)

8.Wrap-up and NV demo

After the hands-on session delegates should have a basic grounding in the use of LoadRunner for performance testing. They’ll leave with a copy of LoadRunner Community Edition to continue the learning process.

At the end of the session we’ll demonstrate the importance of network virtualisation in performance tests by showing test results performed both with and without realistic network conditions.

This workshop will give attendees the knowledge and ability to test REST services through hands on experimentation with sample REST services.

We will cover the general components that make up RESTful services such as verbs, response codes, headers and payloads and how we might test these services in a exploratory and automated testing context

• Writing cross-platform tests
• Automating complex touch gesture actions
• Building robust, non-brittle tests
• Using the page object model with mobile apps
• Debugging test failures
• Parallelizing your testsuite for faster execution

No background is strictly required, however this will be an intermediate- to advanced-level workshop, and attendees already familiar with Selenium or Appium will be able to take greatest advantage of the topics. We will be exploring Appium in a hands-on fashion (using Sauce Labs’s Appium VMs so we can focus on the test code and concepts), and thus we’ll all be working together in the same programming language. While you can write Appium tests in any language, we’ll focus on JavaScript for the sake of the workshop.

This workshop will give attendees the knowledge and ability to separate the UI from end-to-end functional tests and use JavaScript unit testing tools to create lighting fast automated checks for the separated UI automated checks that run in milliseconds and not minutes. They can even be run across multiple web browsers in just seconds to get the all important cross browser compatibility.

We will cover how modern WebApp UIs interact with the server via REST services forming a contract and how we can use this to separate the UI from the Server for testing. To achieve this in practice we will be learning a number of different JavaScript tools and frameworks, including Karma and Mockjax.

Note: Automation programming experience is required as the practicals involve coding.