Learn how Acceptance Test Driven Development (ATDD) provides the process for capturing detailed requirements as acceptance criteria and turn them into as test cases before development begins using Behavior Driven Development (BDD). The BDD approach and Gherkin format is the language used to create easy to understand and actionable scenarios that map from the functional level to the components and units. We will discuss the different approaches to TDD including a realistic approach leveraging BDD to a purest standpoint where TDD use the tests to drive the design of the application. Finally understand how the tools in Visual Studio and Team foundation Server to support BDD such as SpecFlow (Cucumber in .NET), Refactoring tools, and Test Cases in MTM.
When All Teammates Speak The Same Language
Two main problems in software development
It's all about brains
What is BDD?
BDD vs TDD vs ATDD
Three Amigos
Gherkin
Cucumber and Selenium WebDriver
How to use feature files and create steps definitions
Examples
Contents:
Behavior Driven Development (BDD)
Features of BDD
BDD Tools
BDD Framework
Examples of Cucumber/SpecFlow/BDD test
Gherkin – BDD Language
The Problem
Example of Gherkin
The Conclusion
SpecFlow Feature File
Keywords for the Feature File creation
This is an introduction to BDD and the Gherkin syntax. It aims to explain:
* What's Gherkin. Why it's used. An example of all the keywords in Gherkin
* How Gherkin fits into BDD (features files, writing tests first etc)
When All Teammates Speak The Same Language
Two main problems in software development
It's all about brains
What is BDD?
BDD vs TDD vs ATDD
Three Amigos
Gherkin
Cucumber and Selenium WebDriver
How to use feature files and create steps definitions
Examples
Contents:
Behavior Driven Development (BDD)
Features of BDD
BDD Tools
BDD Framework
Examples of Cucumber/SpecFlow/BDD test
Gherkin – BDD Language
The Problem
Example of Gherkin
The Conclusion
SpecFlow Feature File
Keywords for the Feature File creation
This is an introduction to BDD and the Gherkin syntax. It aims to explain:
* What's Gherkin. Why it's used. An example of all the keywords in Gherkin
* How Gherkin fits into BDD (features files, writing tests first etc)
Behavior Driven development is the process of exploring, discovering, defining and driving the desired behavior of software system by using conversation, concrete examples and automated tests.
Test and Behaviour Driven Development (TDD/BDD)Lars Thorup
In this introduction to Test Driven Development (TDD) or Behaviour Driven Development (BDD) we give a high level description of what it is and why it is useful for developers. Then we go into some details on stubs and mocks, test data, UI testing, SQL testing, JavaScript testing, web services testing and how to start doing TDD/BDD on an existing code base.
Let's explore what is agile testing, how agile testing is different than traditional testing. What practices team has to adopt to have parallel testing and how to create your own test automation framework. Test automation frameworks using cucumber, selenium, junit, nunit, rspec, coded UI etc.
A test automation framework defines an organization's way of doing things. It is a set of assumptions, concepts and tools that provide support for automated software testing.
This presentation provides an overview of a Test Automation Framework with BDD and Cucumber. It also includes several open-source initiatives that Rhoynar Software Consulting (www.rhoynar.com) has been working on in the fields of QA Automation and DevOps. Lastly, it also includes links to some of the open-source projects that you can use right now for your work.
- Continuous Integration Infra a la OpenStack - https://github.com/Rhoynar/ci-infra
- An Email Verification Library in Java:
https://github.com/Rhoynar/EmailVerify
- Automatic Test Generation using Selenium WebDriver, Java and TestNG
https://github.com/Rhoynar/AutoTestR
- Barebones BDD and Cucumber Framework integrated with Java Maven and TestNG:
https://github.com/Rhoynar/qa-automation
This power point presentation provides details on syntax of Gherkin language and how it can be used to write accurate user acceptance criteria for user stories.
The Test Automation Pyramid is a useful model to help us understand and discuss automated testing efforts. Generally speaking it is a good practice to have lots of unit tests, fewer component integration tests, fewer API tests, and even fewer UI tests.
Cucumber is a tool which supports development via behavior realization (BDD - Behavior-Driven Development). It is considered to be utilized for creating the tests which can be understood by each and all, even without special technical knowledge.
(by QATestLab)
Cucumber is a testing approach/tool and When integrated with Selenium4 forms a great combination as it allows you to write your tests quickly in an English-like language and Selenium allows you to run on various combinations of browsers. In this session, We will learn about BDD, Cucumber, and the advantages of Integrating them with Selenium.
Behavior Driven development is the process of exploring, discovering, defining and driving the desired behavior of software system by using conversation, concrete examples and automated tests.
Test and Behaviour Driven Development (TDD/BDD)Lars Thorup
In this introduction to Test Driven Development (TDD) or Behaviour Driven Development (BDD) we give a high level description of what it is and why it is useful for developers. Then we go into some details on stubs and mocks, test data, UI testing, SQL testing, JavaScript testing, web services testing and how to start doing TDD/BDD on an existing code base.
Let's explore what is agile testing, how agile testing is different than traditional testing. What practices team has to adopt to have parallel testing and how to create your own test automation framework. Test automation frameworks using cucumber, selenium, junit, nunit, rspec, coded UI etc.
A test automation framework defines an organization's way of doing things. It is a set of assumptions, concepts and tools that provide support for automated software testing.
This presentation provides an overview of a Test Automation Framework with BDD and Cucumber. It also includes several open-source initiatives that Rhoynar Software Consulting (www.rhoynar.com) has been working on in the fields of QA Automation and DevOps. Lastly, it also includes links to some of the open-source projects that you can use right now for your work.
- Continuous Integration Infra a la OpenStack - https://github.com/Rhoynar/ci-infra
- An Email Verification Library in Java:
https://github.com/Rhoynar/EmailVerify
- Automatic Test Generation using Selenium WebDriver, Java and TestNG
https://github.com/Rhoynar/AutoTestR
- Barebones BDD and Cucumber Framework integrated with Java Maven and TestNG:
https://github.com/Rhoynar/qa-automation
This power point presentation provides details on syntax of Gherkin language and how it can be used to write accurate user acceptance criteria for user stories.
The Test Automation Pyramid is a useful model to help us understand and discuss automated testing efforts. Generally speaking it is a good practice to have lots of unit tests, fewer component integration tests, fewer API tests, and even fewer UI tests.
Cucumber is a tool which supports development via behavior realization (BDD - Behavior-Driven Development). It is considered to be utilized for creating the tests which can be understood by each and all, even without special technical knowledge.
(by QATestLab)
Cucumber is a testing approach/tool and When integrated with Selenium4 forms a great combination as it allows you to write your tests quickly in an English-like language and Selenium allows you to run on various combinations of browsers. In this session, We will learn about BDD, Cucumber, and the advantages of Integrating them with Selenium.
Model-based Testing: Taking BDD/ATDD to the Next LevelBob Binder
Slides from presentation at the Chicago Quality Assurance Association, February 25, 2014.
Acceptance Test Driven Development (ATDD) and Behavior Driven Development (BDD) are well-established Agile practices that rely on the knowledge and intuition of testers, product owners, and developers to identify and then translate statements into test suites. But the resulting test suites often cover only a small slice of happy-path behavior. And, as a BDD specification and its associated test code base grows over time, work to maintain it either crowds out new development and testing or, typically, is simply ignored. Either is high-risk. That’s how Agile teams get eaten by the testing BackBlob.Model Based Testing is a tool-based approach to automate the creation of test cases. This presentation will outline the techniques and benefits of MBT, and show how model-based testing can address both problems. A detailed demo of Spec Explorer, a free model-based testing tool shows how a model is constructed and used to create and maintain a test suite.
ATDD - Acceptance Test Driven DevelopmentNaresh Jain
Acceptance test driven development tutorial. This tutorial explains how to take user stories and convert them into working software. Details about Acceptance Criteria and Acceptance tests using FitNesse and FitLibrary are described in this presentation. Also Patterns and Anti-Patterns associated with this are described in this presentation.
In The Seven Habits of Highly Effective People, Stephen R. Covey names "Begin with the End in Mind" as the second of the seven habits. This habit applies not just to individuals, but to software development teams as well. In Acceptance Test Driven Development (ATDD), the Product Owner begins requirements discussions with expectations and examples, and the whole team collaborates to distill these into acceptance tests that define the essence of “Done." Modern testing frameworks enable the team to express the tests in natural language while connecting them to the software so that the tests are automated while the software is being developed. The end result is that the acceptance tests become executable requirements.
These slides explain the ATDD cycle and how it fits with other Agile development and testing practices including TDD, Continuous Integration, and Exploratory Testing.
Despite the belief that a shared context and collaboration drives quality, too often, software testers and quality professionals struggle to find their place within today's integrated agile teams. This session is a practitioner’s view of testing and testing practices within an iterative/incremental development environment. We will begin with a discussion of some of the challenges of testing within an agile environment and delve into the guiding principles of Agile Testing and key enabling practices. Agile Testing necessitates a change in mindset, and it is as much, if not more, about behavior, as it is about skills and tooling, all of which will be explored.
Acceptance Test Driven Development and Robot FrameworkSteve Zhang
This presentation is about using Robot Framework automation test framework to implement Acceptance Test Driven Development, BDD or Specification By Example
In this presentation you will learn how Farm Credit Services of America/Frontier Farm Credit transformed their quality practices and tooling to bring visibility and consistency to Enterprise Quality, including: testing as a team approach, creating an automated test architecture, measuring progress with dashboards and standardizing on a set of testing tools.
Understanding TDD - theory, practice, techniques and tips.Malinda Kapuruge
My talk at the Swinburne University on 09/10/2019. Presented to students as part of the series, Development Projects - Tools and Practices.
Level: Beginner
Cloud and Network Transformation using DevOps methodology : Cisco Live 2015Vimal Suba
Content presented as part of Cisco Live 2015 in San Diego
Why DevOps and what it means to be a DevOps-Enabled Organization?
Recommendations on Toolchain, Metrics framework, best practices and tips to help you embark on your IT Organization on DevOps journey
DevOps, sibling of Agile is born of the need to improve IT service delivery agility to the more stable environment.
DevOps movement emphasizes tearing the boundaries between makers (Development) & caretakers (Operations) of IT services/products.
Prashant technical practices-tdd for xebia eventXebia India
Theme: Agile Technical Practices
Epic: TDD implementation
Stories:
Context of TDD
What is TDD
Response of Developers to TDD implementation
Practices complimenting TDD
Success with TDD
Camunda Day Amsterdam 2019: Best Practices for successfully introducing Camun...camunda services GmbH
We know the uphill struggle that introducing new software entails. In this presentation, Robert Gimbel, CRO at Camunda, shared best practice insights drawn from more than 200 customers who’ve adopted Camunda, from first project to broad-scale adoption, so you avoid commit pitfalls and hit the ground running.
Lean-Agile Development with SharePoint - Bill AyersSPC Adriatics
SharePoint gives us a great platform for developing sophisticated intranet portals and collaboration sites and many other workloads. But it can also be a challenge to use modern software development frameworks like Scrum and XP. Wouldn’t it be great if we could get all the benefits of Agile practices – faster development, predictable deliveries, better quality, less stress and happy stakeholders? In this session we will cover the definitions of Lean, Agile, Scrum, Kanban, XP, and TDD. Then we will look at the specific challenges around Agile SharePoint development and some development techniques to overcome these obstacles. This talk covers both project delivery and engineering. We’ll look at unit tests, integration tests, UI tests, continuous integration and, of course, test-driven development (TDD) with practical experiences from real-life Agile SharePoint projects.
Test Driven Development – What Works And What Doesn’t Synerzip
This webinar covers the role of TDD and CI and what pitfalls to watch out for.
Stay tuned for Synerzip's upcoming webinars that you might be interested in https://www.synerzip.com/webinars/
Enter the mind of an Agile Developer, BSG shares with you how we do software development and how to embed agile methodologies into your development process.
The Art of the Pitch: WordPress Relationships and SalesLaura Byrne
Clients don’t know what they don’t know. What web solutions are right for them? How does WordPress come into the picture? How do you make sure you understand scope and timeline? What do you do if sometime changes?
All these questions and more will be explored as we talk about matching clients’ needs with what your agency offers without pulling teeth or pulling your hair out. Practical tips, and strategies for successful relationship building that leads to closing the deal.
Builder.ai Founder Sachin Dev Duggal's Strategic Approach to Create an Innova...Ramesh Iyer
In today's fast-changing business world, Companies that adapt and embrace new ideas often need help to keep up with the competition. However, fostering a culture of innovation takes much work. It takes vision, leadership and willingness to take risks in the right proportion. Sachin Dev Duggal, co-founder of Builder.ai, has perfected the art of this balance, creating a company culture where creativity and growth are nurtured at each stage.
Software Delivery At the Speed of AI: Inflectra Invests In AI-Powered QualityInflectra
In this insightful webinar, Inflectra explores how artificial intelligence (AI) is transforming software development and testing. Discover how AI-powered tools are revolutionizing every stage of the software development lifecycle (SDLC), from design and prototyping to testing, deployment, and monitoring.
Learn about:
• The Future of Testing: How AI is shifting testing towards verification, analysis, and higher-level skills, while reducing repetitive tasks.
• Test Automation: How AI-powered test case generation, optimization, and self-healing tests are making testing more efficient and effective.
• Visual Testing: Explore the emerging capabilities of AI in visual testing and how it's set to revolutionize UI verification.
• Inflectra's AI Solutions: See demonstrations of Inflectra's cutting-edge AI tools like the ChatGPT plugin and Azure Open AI platform, designed to streamline your testing process.
Whether you're a developer, tester, or QA professional, this webinar will give you valuable insights into how AI is shaping the future of software delivery.
"Impact of front-end architecture on development cost", Viktor TurskyiFwdays
I have heard many times that architecture is not important for the front-end. Also, many times I have seen how developers implement features on the front-end just following the standard rules for a framework and think that this is enough to successfully launch the project, and then the project fails. How to prevent this and what approach to choose? I have launched dozens of complex projects and during the talk we will analyze which approaches have worked for me and which have not.
JMeter webinar - integration with InfluxDB and GrafanaRTTS
Watch this recorded webinar about real-time monitoring of application performance. See how to integrate Apache JMeter, the open-source leader in performance testing, with InfluxDB, the open-source time-series database, and Grafana, the open-source analytics and visualization application.
In this webinar, we will review the benefits of leveraging InfluxDB and Grafana when executing load tests and demonstrate how these tools are used to visualize performance metrics.
Length: 30 minutes
Session Overview
-------------------------------------------
During this webinar, we will cover the following topics while demonstrating the integrations of JMeter, InfluxDB and Grafana:
- What out-of-the-box solutions are available for real-time monitoring JMeter tests?
- What are the benefits of integrating InfluxDB and Grafana into the load testing stack?
- Which features are provided by Grafana?
- Demonstration of InfluxDB and Grafana using a practice web application
To view the webinar recording, go to:
https://www.rttsweb.com/jmeter-integration-webinar
Accelerate your Kubernetes clusters with Varnish CachingThijs Feryn
A presentation about the usage and availability of Varnish on Kubernetes. This talk explores the capabilities of Varnish caching and shows how to use the Varnish Helm chart to deploy it to Kubernetes.
This presentation was delivered at K8SUG Singapore. See https://feryn.eu/presentations/accelerate-your-kubernetes-clusters-with-varnish-caching-k8sug-singapore-28-2024 for more details.
Smart TV Buyer Insights Survey 2024 by 91mobiles.pdf91mobiles
91mobiles recently conducted a Smart TV Buyer Insights Survey in which we asked over 3,000 respondents about the TV they own, aspects they look at on a new TV, and their TV buying preferences.
Kubernetes & AI - Beauty and the Beast !?! @KCD Istanbul 2024Tobias Schneck
As AI technology is pushing into IT I was wondering myself, as an “infrastructure container kubernetes guy”, how get this fancy AI technology get managed from an infrastructure operational view? Is it possible to apply our lovely cloud native principals as well? What benefit’s both technologies could bring to each other?
Let me take this questions and provide you a short journey through existing deployment models and use cases for AI software. On practical examples, we discuss what cloud/on-premise strategy we may need for applying it to our own infrastructure to get it to work from an enterprise perspective. I want to give an overview about infrastructure requirements and technologies, what could be beneficial or limiting your AI use cases in an enterprise environment. An interactive Demo will give you some insides, what approaches I got already working for real.
Unsubscribed: Combat Subscription Fatigue With a Membership Mentality by Head...
Acceptance Test Driven Development
1. Acceptance Test Driven Development
Mike Douglas
Mikedouglas *AT* Deliveron.com
@mikedouglasdev
Kim Dietz
Kimdietz *AT* Deliveron.com
2. ABOUT DELIVERON
Deliveron is a project-based consulting organization that delivers business-driven
technology solutions. Our high success rate is the result of our:
• Team approach with client engagements
• Integrated client partnership and collaboration
• Deep expertise in core Microsoft technologies
• Project leadership and guidance
• Agile delivery framework and ALM best practices
• Strategic offerings
We provide solutions across five primary areas:
• Custom Application Development using
Microsoft Technologies
• Portals, Workflow, Collaboration, and
Enterprise Social
• Cloud and Hybrid Platforms
• Enterprise Application Integration
• Analytics and Business Intelligence
Nebraska Code Camp Gold Sponsor
3. Acceptance Test Driven Development
Mike Douglas
mikedouglas@Deliveron.com
@mikedouglasdev
Kim Dietz
kimdietz@Deliveron.com
4. AGENDA
• What is Agile Testing?
• Differentiating TDD, ATDD, and BDD
• Why use ATDD?
• Understanding the Process
5. WHAT IS AGILE TESTING?
• Traditional / Waterfall
– Huge Word documents, well protected
– Documents don’t work so well…
• Too expensive = time to create and maintain
• What if the unspeakable happens…There’s a change!?!
• Out of date as soon as it is signed off
• Can’t use to prove the intent of the spec is met
• No run / test button in Word
6. WHAT IS AGILE TESTING?
• Traditional / Waterfall
– Waiting until development is complete
• Testing time is often compressed because development
took longer than planned
• Typically this is the first time the users get to see the
application
• Usually what they asked for, less often it is what they
want
7. WHAT IS AGILE TESTING?
• Agile
– We have user stories…
• Expressing desirements
• User stories represent needed conversations
• User Stories are the requirements, but only until done, done.
– Need something to document that the conversation took place
• Written as the functionality is now done and this is how it
should work
• Testable outcome can be verified
• To become executable specifications
9. TDD, ATDD, AND BDD
• 2 levels of Test First Development
– TDD (Test Driven Development)
– ATDD (Acceptance Test Driven Development)
10. Create failing
Unit Test
Make the test
pass
Refactor
Unit / Component
TDD, ATDD, AND BDD
ATDD TDD
Convert to
Scenarios
Create failing
Acceptance Test
Make the test
pass
For each Scenario
Capture Acceptance
Criteria
Create User Story
Verifiable Working
Software
11. TDD, ATDD, AND BDD
• TDD
– Developer focused – Unit / Component Level
– Validates “building the code right”
– “Encourages simple designs and inspires software” - Kent
Beck
– Usually tests code in isolation (Dependency Injection and
Mocking frameworks)
– Advantages
• Enables you to take small steps when writing software
• Prevents gold plated software
12. TDD, ATDD, AND BDD
• TDD
– General Steps
• Red -> Green -> Refactor
– Write a failing Test
– Write the code to make the test pass
– Refactor code and know you didn’t break any functionality
14. TDD, ATDD, AND BDD
• ATDD
– Acceptance level or functional level
– Validates “building the right code”
– Executable Specifications
• Expressing requirements such that they are also executable tests
• Word can’t prove software works
• Meaningful to business, testers, and developers
– General Steps
• Acceptance Criteria
• Convert to Executable Requirement / Test Case
• In Parallel
– Dev - Write Code to make tests pass
– Testing - Manually Test and Pass
15. TDD, ATDD, AND BDD
• Scenarios
– Executable acceptance criteria
– Gherkin
• Format to capture conversations with business
• GIVEN – some context…
• WHEN – some action is performed…
• THEN – some result can be verified…
16. TDD, ATDD, AND BDD
• BDD
– Behavior Driven Development
– Specific implementation of ATDD / TDD using Gherkin
language
– Creates the executable scenario with automated tests
– Dependent on a tool such as Cucumber for Java/Perl
(others) or SpecFlow for .NET
– Functional level (xBehave) or developer level (xSpec)
17. TDD, ATDD, AND BDD
• BDD Tools
– Functional written by team – SpecFlow or NBehave
– Developer level – Nspec
• SpecFlow
– Integration with Visual Studio
Visual Studio Extensions Project NuGet Packages
18. Create failing
Unit Test
Make the test
pass
Refactor
Unit / Component
TDD, ATDD, AND BDD
ATDD TDD
Convert to
Scenarios
Create failing
Acceptance Test
Make the test
pass
For each Scenario
Capture Acceptance
Criteria
Create User Story
Verifiable Working
Software
Can do ATDD and TDD separately
or together
19. WHY ATDD?
• Test maintainability
– Refactor code with minimal impact on the tests
• Avoid misunderstood requirements
– Common language so that business, testers, and developers can
better understand the requirements
• Automated regression testing is delivered as part of the
project
– Automated Executable Specifications
• Reporting of ATDD progress
– Provides great insight of progress during Sprints
• Testing the functionality that has been requested
– Preventing the gold plated code
21. UNDERSTANDING THE PROCESS
• Requirement Definition (User Story Statement)
– UINVEST
• U = Understandable – story must make sense
• I = Independent – self contained
• N = Negotiable – can be changed until added to an
iteration
• V = Valuable – deliver value
• E = Estimatable – estimate a size of the story
• S = Small – stories should not be too big
• T = Testable – we must be able to test it
23. UNDERSTANDING THE PROCESS
• How to Define Acceptance Criteria (Definition of
Done)
– Defined for each User Story during the Iteration Planning
meeting
– Conditions that must be met to consider the Story “Done”
• Includes Functional & Non-Functional Requirements
– High level definition of what is acceptable and what is not
– Actionable in order to translate into Test Case(s)
– Either everything is “Done” or the Story is incomplete
25. UNDERSTANDING THE PROCESS
• Converting Acceptance Criteria to Scenario/Test Case
– Test Case creation for each User Story takes place during
the Iteration Planning or Iteration Definition meeting
– Involves the Development Team and the Business
– Test Cases are the executable specifications of the
Acceptance Criteria
– Gherkin
• Format to capture conversations with business
• GIVEN – some context…
• WHEN – some action is performed…
• THEN – some result can be verified…
26. UNDERSTANDING THE PROCESS
• Implementing test cases as part of the development
process
– Developer creates the failing SpecFlow tests
– BA/QA defines the test case steps, input values and
expected outcomes that will be used for the execution of
the test cases
27. UNDERSTANDING THE PROCESS
• Implementing test cases as part of the development
process
– Developer makes the appropriate code changes until the
SpecFlow scenario passes
– The Developer updates the User Story state to Resolved
and the BA/QA executes any remaining manual test cases
– When all test cases are in a Passing state, the User Story is
then handed off to the appropriate business user to
complete UAT and Close the User Story.
29. UNDERSTANDING THE PROCESS
• Regression Tests Delivered During Iteration
– Not only has the Team delivered the User Story, they now
also have a repository of regression test cases!
– Benefits the team whether the Test Cases are Automated
or executed manually.
30. UNDERSTANDING THE PROCESS
• BA/QA Demo
– User Story in Visual Studio
• Linked Test Cases
– Open MTM
• Iteration Test Plans
– Test Suites
– Test Cases
31. UNDERSTANDING THE PROCESS
• Developer Demo
– Functional Tests
• In Process
• Easy to Mock
• Fast, bypass UI
– Coded UI Test
• Out of process
• Test against live site
• Tests UI
• Page Object Pattern
32. UNDERSTANDING THE PROCESS
• Options
– QA members replacing their manual testing with writing
SpecFlow tests
– Linking between the test cases and automated provide
automation from Test Manager
– Automated Tests can be run as part of nightly
33. UNDERSTANDING THE PROCESS
• Call to Action
– Try ATDD in your process
– Try TDD in your process
– Let us know if you would like any help or have questions
– Let us know if you want us to come talk to your teams
34. 1 1 5 1 6 M i r a c l e H i l l s D r i v e S u i t e 2 0 1 O m a h a , N E 6 8 1 5 4
4 0 2 . 2 3 8 . 1 3 9 9 | w w w . d e l i v e r o n . c o m | c o n t a c t u s @ d e l i v e r o n . c o m
Editor's Notes
How many of you teams are doing TDD where you are unit tests before writing code?
How many are teams are doing ATDD? Using scenarios with Given, When, Then?
Software project? Without bug? With bugs found at the end?
How many of you teams are doing TDD where you are unit tests before writing code?
How many are teams are doing ATDD? Using scenarios with Given, When, Then?
Software project? Without bug? With bugs found at the end?
End to end to show the full process from the testing standpoint and developer standpoint
Probably wouldn’t be here if not
Agile fixes all of the problems, right?
If something breaks in the application, where is the first place you look to see how the application performs? Most would say the code. Requirements might not be up to date. Need something closer to the code. Rule should be validated as a test, if it isn’t there, add it. Therefore your tests become the truth center for requirements.
This is where our acronyms come in
Who knows what gold plated software is? Sounds awesome, I want some! But like many (maybe most) of you know it is bad. Gold plated means there is a lot of extra code to make sure it can do anything, not just the requirements. We want barely sufficient code that does just what we asked it to do…
Right code – testing to make sure it work but also making sure it is what they really want
Why do we so strongly believe in ATDD?
Kim will show some of the reporting in more details in just a bit
Process starts with defining the desirements of the users by creating user stories
Defined during Release and/or Iteration Planning
Acronym used to help process of creating User Stories
Many tools to use to support the Agile methodology - we use TFS on the majority of our Client projects
Example of User Story work item in TFS – Deliveron Template has been updated to include the Role, Goal & Reason
Deliveron’s ALM Guidance?
Functional – Clicking the “Continue” button takes the user to the next page
Non-Functional – The Button is Green
Use clear, simple language that is clear to the business and Dev team
Actionable = Testable. Words such as “Engaging” or “Fun” should not be used. These are not testable attributes.
Example shows how we recommend documenting the Definition of Done for each User Story in TFS
Description is a high level explanation of the User Story – usually provided by the Business to add more context around the purpose of the story
This is where a lot of teams struggle – converting the acceptance criteria into pieces that are testable
Acceptance Criteria was the high level requirements of the story – Test Cases are going to become the detailed requirements
Test Cases will be a reflection of the Definition of Done as it applies to real life scenarios
Test cases are the definition of the application as it is intended to be used
Test Cases should cover both the positive and negative scenarios
There is not always a one to one relationship between the Acceptance Criteria and Test Cases
Can be one to many, many to one so on and so forth
You should always have at a minimum of one test case for each user story
If there is a not enough time during the Planning/Definition meetings to complete the initial Test Case creation (Given, When & Then – not steps)..
As part of the Deliveron ALM Guidance, we recommend at least getting through the top 3-5 stack ranked stories that the team has committed to for the Iteration
Are any teams currently using this process? (and then go into Gherkin)
We strongly recommend using the Gherkin format as it allow teams to describe the details of the user story in a way that is consistent and understood by both Development Teams and the business
Sometimes the actual expected steps are a bit unknown until the feature is delivered to test – that’s alright, the steps can always be updated/modified when appropriate
Using ATDD to write our test cases and perform the manual testing, recently we have be introducing SpecFlow to add automation. Additionally we are looking at these options to continue to mature our process.
Using ATDD to write our test cases and perform the manual testing, recently we have be introducing SpecFlow to add automation. Additionally we are looking at these options to continue to mature our process.