This document provides an overview of automated testing in AngularJS, including unit testing, end-to-end testing, and acceptance testing using tools like Protractor and CucumberJS. It discusses the benefits of automated testing such as enabling safe refactoring and reducing bugs. It then demonstrates how to set up testing frameworks like Protractor and Karma and write tests using page objects and test-driven development. The document also covers acceptance testing with CucumberJS by writing step definitions and features in Gherkin and linking them to tests.
This document discusses testing AngularJS applications. It introduces popular testing frameworks like Jasmine and Karma that can be used to write unit tests and automate testing. Jasmine is typically used for testing AngularJS code and examples are given of writing tests with Jasmine. Karma is presented as a tool to automate testing by running tests in browsers. Protractor is introduced for end-to-end testing of front-end DOM elements. The document argues that front-end testing will become more important and integrated into development as tools continue to improve.
Carmen Popoviciu - Protractor styleguide | Codemotion Milan 2015Codemotion
In this talk, I would like to speak about best practices for writing e2e tests with Protractor. The styleguide that I will introduce, is a joint initiative of mine and @andresdom from Google. Some of the subjects that will be covered include why e2e testing is important, what e2e tests should cover, naming conventions, selector strategies, page objects, helper objects and performance considerations. That and lots of smileys obviously, because we wanted to smiley all the things ...right? ¯\_(ツ)_/¯
Andrew Eisenberg gives an overview of UI testing with Protractor. He discusses installing and running Protractor, writing basic tests, more complex test scenarios using page objects and promises, debugging tips, and considerations around when and how to use Protractor for UI testing AngularJS applications. While Protractor is a powerful tool, he notes it has limitations and maintenance costs, and manual testing may be better for unstable UIs and use cases in flux.
This document provides an overview of Protractor, an end-to-end test framework for AngularJS applications. It discusses prerequisites for setting up Protractor, including installing Node.js and Java. Steps are outlined for configuring Protractor, writing a first test, and running tests. Code examples are also shown for interacting with Angular elements in tests using Protractor capabilities. The document aims to demonstrate the basics of Protractor through a simple todo application example and code snippets.
The document discusses Protractor, an end-to-end test framework for AngularJS applications. It provides an overview of Protractor, how it differs from Selenium WebDriver, how to install and configure it, how to write tests using the Page Object Model pattern, and how to structure tests into suites and specs. Key aspects covered include Protractor's Angular-specific features, use of Jasmine, and capabilities like multi-browser testing.
Unit testing Angular applications is important to ensure components and services work as expected. There are several frameworks that can be used for Angular unit testing, including Jasmine for writing tests and Karma as a test runner. Key aspects of unit testing covered in the document include: using test doubles like stubs and spies to isolate the system under test; focusing tests on small units and targeting specific assertions; and dealing with asynchronous code. The document also provides examples of writing pure unit tests in Jasmine without dependencies and using spies to control dependencies.
Unit testing and end-to-end (E2E) testing are important types of automated testing for JavaScript applications. Unit tests focus on testing individual functions or components in isolation to catch bugs, while E2E tests ensure that user flows work as expected by interacting with the application through a browser. The presentation discussed setting up testing frameworks like Karma and Jasmine for unit testing and Protractor for E2E testing. It also covered writing testable code, handling dependencies through dependency injection, and selecting elements and interacting with them during E2E tests.
An intro to nightwatch(a tool to create and run functional tests, e2e tests using selenium in the background) and examples of cases, also how to integrate nightwatch to a Continous Integration tool
This document discusses testing AngularJS applications. It introduces popular testing frameworks like Jasmine and Karma that can be used to write unit tests and automate testing. Jasmine is typically used for testing AngularJS code and examples are given of writing tests with Jasmine. Karma is presented as a tool to automate testing by running tests in browsers. Protractor is introduced for end-to-end testing of front-end DOM elements. The document argues that front-end testing will become more important and integrated into development as tools continue to improve.
Carmen Popoviciu - Protractor styleguide | Codemotion Milan 2015Codemotion
In this talk, I would like to speak about best practices for writing e2e tests with Protractor. The styleguide that I will introduce, is a joint initiative of mine and @andresdom from Google. Some of the subjects that will be covered include why e2e testing is important, what e2e tests should cover, naming conventions, selector strategies, page objects, helper objects and performance considerations. That and lots of smileys obviously, because we wanted to smiley all the things ...right? ¯\_(ツ)_/¯
Andrew Eisenberg gives an overview of UI testing with Protractor. He discusses installing and running Protractor, writing basic tests, more complex test scenarios using page objects and promises, debugging tips, and considerations around when and how to use Protractor for UI testing AngularJS applications. While Protractor is a powerful tool, he notes it has limitations and maintenance costs, and manual testing may be better for unstable UIs and use cases in flux.
This document provides an overview of Protractor, an end-to-end test framework for AngularJS applications. It discusses prerequisites for setting up Protractor, including installing Node.js and Java. Steps are outlined for configuring Protractor, writing a first test, and running tests. Code examples are also shown for interacting with Angular elements in tests using Protractor capabilities. The document aims to demonstrate the basics of Protractor through a simple todo application example and code snippets.
The document discusses Protractor, an end-to-end test framework for AngularJS applications. It provides an overview of Protractor, how it differs from Selenium WebDriver, how to install and configure it, how to write tests using the Page Object Model pattern, and how to structure tests into suites and specs. Key aspects covered include Protractor's Angular-specific features, use of Jasmine, and capabilities like multi-browser testing.
Unit testing Angular applications is important to ensure components and services work as expected. There are several frameworks that can be used for Angular unit testing, including Jasmine for writing tests and Karma as a test runner. Key aspects of unit testing covered in the document include: using test doubles like stubs and spies to isolate the system under test; focusing tests on small units and targeting specific assertions; and dealing with asynchronous code. The document also provides examples of writing pure unit tests in Jasmine without dependencies and using spies to control dependencies.
Unit testing and end-to-end (E2E) testing are important types of automated testing for JavaScript applications. Unit tests focus on testing individual functions or components in isolation to catch bugs, while E2E tests ensure that user flows work as expected by interacting with the application through a browser. The presentation discussed setting up testing frameworks like Karma and Jasmine for unit testing and Protractor for E2E testing. It also covered writing testable code, handling dependencies through dependency injection, and selecting elements and interacting with them during E2E tests.
An intro to nightwatch(a tool to create and run functional tests, e2e tests using selenium in the background) and examples of cases, also how to integrate nightwatch to a Continous Integration tool
Client side unit tests - using jasmine & karmaAdam Klein
This document discusses client-side testing using Jasmine and Karma. It introduces Jasmine as the most popular testing framework for writing unit tests in the browser. It demonstrates a simple example of using Jasmine to test a Person constructor function. It then discusses Karma, a test runner that makes browser testing seamless. Karma allows running tests across multiple browsers simultaneously. The document also covers techniques for testing AngularJS controllers and services, including mocking external server calls. It emphasizes that while tests may pass using mocks, the mocks represent the contract with the external code being tested.
Protractor end-to-end testing framework for angular jscodeandyou forums
Protractor is an end-to-end test framework for AngularJS applications that runs tests against a real browser, interacting with the application as a user would. It is built on WebDriverJS and uses native events and browser-specific drivers to test asynchronous behavior and support for AngularJS. Protractor tests can run in any browser and interact directly with page elements rather than testing JavaScript code.
Intro to Service Worker API and its use casessatejsahu
The document introduces service workers, which are scripts that run in the background to cache assets and handle requests to provide functionality even when a network is unavailable; it discusses key service worker concepts like promises, registration, installation and activation; and it provides examples of how service workers can be used to improve performance and the offline experience on a web page.
Confused by testing terms and jargon? This talk walks through testing web applications, explaining the difference between unit testing and end to end testing. Several tools and concepts are also explored through a demo section.
Sample projects can be found at https://github.com/sethmcl/testing_web_applications.
This document provides an overview of unit testing in Angular, including setting up Angular CLI for testing, the tools used for testing like Karma and Jasmine, how to write test specs with expectations and matchers, how to set up and tear down tests, and how to test different parts of an Angular application like components, templates, dependencies, and HTTP services. The agenda also includes debugging tests and generating code coverage reports.
ForwardJS 2017 - Fullstack end-to-end Test Automation with node.jsMek Srunyu Stittri
Slide deck for ForwardJS 2017 in San Francisco - March 1st 2017
https://forwardjs.com/schedule#lecture-224
Airware builds hardware, software and cloud for commercial drones. We have transitioned to Node.js for cloud functional test automation in 2015. The purpose of this is to unite Fullstack developers and Automation engineers to speak in the same language which is JavaScript. With a year worth of lessons learnt, we will share the challenges involved with building a full-stack test automation framework with Node.js while using the latest and greatest in JavaScript tools.
Automated testing of web applications using JavaScript can provide confidence that changes and new installations do not break existing functionality. There are various types of tests, including unit, end-to-end, compatibility, and performance tests. Popular JavaScript testing tools include QUnit for unit testing, Selenium and Protractor for end-to-end testing, and PhantomJS for headless browser testing without a GUI. These tools can test JavaScript applications and allow writing tests in JavaScript when the application itself is also written in JavaScript.
This document compares popular JavaScript automation frameworks for testing Node.js applications, including Protractor, WebdriverIO, and NightwatchJS. It provides details on each framework, such as supported features, syntax, and advantages. NightwatchJS is highlighted as a good option for end-to-end testing due to its built-in test runner, support for parallel testing, cross-browser testing, and mobile testing. While it requires callbacks, NightwatchJS has an easy syntax, inbuilt debugging, and is overall presented as a strong framework for end-to-end testing of Node.js applications.
Protractor is a framework for end-to-end testing of AngularJS applications. It interacts with the application and simulates user actions like clicking and entering text. Protractor uses Angular-specific locators for elements and waits for Angular-specific conditions like promises to resolve. It generates test reports using Jasmine and supports continuous integration with tools like Sauce Labs.
Angular Unit Testing from the TrenchesJustin James
For a number of years now we have been hearing about all of the benefits that automated unit testing provides like increasing our quality, catching errors earlier, ensuring that all developers are testing in the same manner and deploying updates with high confidence that nothing will break. Testing a Web UI though was difficult and fragile which meant that typically we had no automated unit test for our Web UI. This is no longer the case with the latest release of Angular. Unit testing is now a first class citizen in Angular.
Out of the box, the project generated by the Angular CLI has unit testing setup with Karma and Jasmine and includes sample tests. Generating new components, services, and pipes includes the unit test Spec file already wired up. Thus allowing you to focus on writing your unit tests and not on the infrastructure needed to get them running. The barriers to writing unit test have been destroyed.
This talk will walk through getting started unit testing your Angular components, services, and pipes. Along the way I will share the tips and tricks that I have learned as I have implemented unit testing on my Angular projects at a Fortune 100 company. You will walk away ready to immediately implement unit testing on your Angular project.
Slides for the presentation I did for the Vancouver AngularJS meetup group.
http://www.meetup.com/vanangularJS/events/216391652/
The code is available on my github account.
https://github.com/aeisenberg/angular-app/tree/vanangular-protractor
(Notice the branch is not master.)
The Angular framework is great for building large-scale web applications that can be maintained and enhanced. When you're building enterprise-level apps, testing is vital to the development process. Testing improves the quality of code and reduces maintenance, saving both time and money. Developers who know how to build and leverage tests are highly valued by their clients and companies.
Efficient JavaScript Unit Testing, May 2012Hazem Saleh
One of the biggest challenges of many web applications is the support on the different browsers with different versions. JavaScript code that runs on Safari does not necessarily mean it will work on IE or Firefox or Google chrome. This challenge is inherited from the lack of testing the JavaScript code that lives in the presentation tier from day one. Without unit testing the JavaScript code, organization will pay much money for testing, re-testing, and re-testing web applications for just deciding upgrading or supporting new browsers. This presentation shows the solution of this problem.
This document discusses end-to-end testing with Protractor.js. It introduces Protractor and describes how it can be used to test Angular applications directly within browsers using WebDriverJS. It also discusses best practices like using page object patterns to organize tests and hide implementation details. Key aspects covered include setting up tests, writing maintainable page objects, and decomposing pages into reusable sections and fields.
Using JHipster for generating Angular/Spring Boot appsYakov Fain
1. The document discusses using JHipster, an open source tool, to generate Angular and Spring Boot applications. It demonstrates generating both monolithic and microservices applications.
2. Key features of JHipster covered include generating entities, internationalization, and deployment options. Running and developing applications in both development and production modes is explained.
3. Examples are provided of generating sample applications using JHipster's online generator and locally installed generator. This includes reviewing the generated code and application structure.
Session from GIDS 2014, showing how to do automated Web testing using a variety of JavaScript frameworks, including QUnit, Jasmine, Protractor, Selenium, and PhantomJS
The document discusses unit testing in Angular. It explains that there are three main parts to unit testing: the process to run tests, a test runner, and an assertion library. Karma is recommended as a test runner that works with Jasmine, a popular assertion library for writing Angular unit tests. The document provides examples of how to set up Karma and write unit tests using Jasmine's matcher methods and expectations. It emphasizes the importance of writing code in a testable way by isolating dependencies and single responsibilities.
The document discusses best practices, tips, performance, and debugging strategies for Protractor, an end-to-end testing framework for AngularJS applications. It addresses common problems like unknown window sizes, fragile tests due to small HTML changes, and long test run times. Solutions include setting the window size before tests, using page objects to abstract the HTML, enabling sharding to run tests in parallel, and integrating with IDEs for debugging. The tips are from Sergey Bolshchikov, a developer advocate and creator of resources for front-end developers.
This document provides information on setting up and running tests with Protractor. It discusses installing Node.js, Protractor and other dependencies. It also includes samples of Protractor configuration files for running tests on different browsers, in parallel and headless mode. References are provided at the end for Protractor tutorials, documentation and code samples.
Client side unit tests - using jasmine & karmaAdam Klein
This document discusses client-side testing using Jasmine and Karma. It introduces Jasmine as the most popular testing framework for writing unit tests in the browser. It demonstrates a simple example of using Jasmine to test a Person constructor function. It then discusses Karma, a test runner that makes browser testing seamless. Karma allows running tests across multiple browsers simultaneously. The document also covers techniques for testing AngularJS controllers and services, including mocking external server calls. It emphasizes that while tests may pass using mocks, the mocks represent the contract with the external code being tested.
Protractor end-to-end testing framework for angular jscodeandyou forums
Protractor is an end-to-end test framework for AngularJS applications that runs tests against a real browser, interacting with the application as a user would. It is built on WebDriverJS and uses native events and browser-specific drivers to test asynchronous behavior and support for AngularJS. Protractor tests can run in any browser and interact directly with page elements rather than testing JavaScript code.
Intro to Service Worker API and its use casessatejsahu
The document introduces service workers, which are scripts that run in the background to cache assets and handle requests to provide functionality even when a network is unavailable; it discusses key service worker concepts like promises, registration, installation and activation; and it provides examples of how service workers can be used to improve performance and the offline experience on a web page.
Confused by testing terms and jargon? This talk walks through testing web applications, explaining the difference between unit testing and end to end testing. Several tools and concepts are also explored through a demo section.
Sample projects can be found at https://github.com/sethmcl/testing_web_applications.
This document provides an overview of unit testing in Angular, including setting up Angular CLI for testing, the tools used for testing like Karma and Jasmine, how to write test specs with expectations and matchers, how to set up and tear down tests, and how to test different parts of an Angular application like components, templates, dependencies, and HTTP services. The agenda also includes debugging tests and generating code coverage reports.
ForwardJS 2017 - Fullstack end-to-end Test Automation with node.jsMek Srunyu Stittri
Slide deck for ForwardJS 2017 in San Francisco - March 1st 2017
https://forwardjs.com/schedule#lecture-224
Airware builds hardware, software and cloud for commercial drones. We have transitioned to Node.js for cloud functional test automation in 2015. The purpose of this is to unite Fullstack developers and Automation engineers to speak in the same language which is JavaScript. With a year worth of lessons learnt, we will share the challenges involved with building a full-stack test automation framework with Node.js while using the latest and greatest in JavaScript tools.
Automated testing of web applications using JavaScript can provide confidence that changes and new installations do not break existing functionality. There are various types of tests, including unit, end-to-end, compatibility, and performance tests. Popular JavaScript testing tools include QUnit for unit testing, Selenium and Protractor for end-to-end testing, and PhantomJS for headless browser testing without a GUI. These tools can test JavaScript applications and allow writing tests in JavaScript when the application itself is also written in JavaScript.
This document compares popular JavaScript automation frameworks for testing Node.js applications, including Protractor, WebdriverIO, and NightwatchJS. It provides details on each framework, such as supported features, syntax, and advantages. NightwatchJS is highlighted as a good option for end-to-end testing due to its built-in test runner, support for parallel testing, cross-browser testing, and mobile testing. While it requires callbacks, NightwatchJS has an easy syntax, inbuilt debugging, and is overall presented as a strong framework for end-to-end testing of Node.js applications.
Protractor is a framework for end-to-end testing of AngularJS applications. It interacts with the application and simulates user actions like clicking and entering text. Protractor uses Angular-specific locators for elements and waits for Angular-specific conditions like promises to resolve. It generates test reports using Jasmine and supports continuous integration with tools like Sauce Labs.
Angular Unit Testing from the TrenchesJustin James
For a number of years now we have been hearing about all of the benefits that automated unit testing provides like increasing our quality, catching errors earlier, ensuring that all developers are testing in the same manner and deploying updates with high confidence that nothing will break. Testing a Web UI though was difficult and fragile which meant that typically we had no automated unit test for our Web UI. This is no longer the case with the latest release of Angular. Unit testing is now a first class citizen in Angular.
Out of the box, the project generated by the Angular CLI has unit testing setup with Karma and Jasmine and includes sample tests. Generating new components, services, and pipes includes the unit test Spec file already wired up. Thus allowing you to focus on writing your unit tests and not on the infrastructure needed to get them running. The barriers to writing unit test have been destroyed.
This talk will walk through getting started unit testing your Angular components, services, and pipes. Along the way I will share the tips and tricks that I have learned as I have implemented unit testing on my Angular projects at a Fortune 100 company. You will walk away ready to immediately implement unit testing on your Angular project.
Slides for the presentation I did for the Vancouver AngularJS meetup group.
http://www.meetup.com/vanangularJS/events/216391652/
The code is available on my github account.
https://github.com/aeisenberg/angular-app/tree/vanangular-protractor
(Notice the branch is not master.)
The Angular framework is great for building large-scale web applications that can be maintained and enhanced. When you're building enterprise-level apps, testing is vital to the development process. Testing improves the quality of code and reduces maintenance, saving both time and money. Developers who know how to build and leverage tests are highly valued by their clients and companies.
Efficient JavaScript Unit Testing, May 2012Hazem Saleh
One of the biggest challenges of many web applications is the support on the different browsers with different versions. JavaScript code that runs on Safari does not necessarily mean it will work on IE or Firefox or Google chrome. This challenge is inherited from the lack of testing the JavaScript code that lives in the presentation tier from day one. Without unit testing the JavaScript code, organization will pay much money for testing, re-testing, and re-testing web applications for just deciding upgrading or supporting new browsers. This presentation shows the solution of this problem.
This document discusses end-to-end testing with Protractor.js. It introduces Protractor and describes how it can be used to test Angular applications directly within browsers using WebDriverJS. It also discusses best practices like using page object patterns to organize tests and hide implementation details. Key aspects covered include setting up tests, writing maintainable page objects, and decomposing pages into reusable sections and fields.
Using JHipster for generating Angular/Spring Boot appsYakov Fain
1. The document discusses using JHipster, an open source tool, to generate Angular and Spring Boot applications. It demonstrates generating both monolithic and microservices applications.
2. Key features of JHipster covered include generating entities, internationalization, and deployment options. Running and developing applications in both development and production modes is explained.
3. Examples are provided of generating sample applications using JHipster's online generator and locally installed generator. This includes reviewing the generated code and application structure.
Session from GIDS 2014, showing how to do automated Web testing using a variety of JavaScript frameworks, including QUnit, Jasmine, Protractor, Selenium, and PhantomJS
The document discusses unit testing in Angular. It explains that there are three main parts to unit testing: the process to run tests, a test runner, and an assertion library. Karma is recommended as a test runner that works with Jasmine, a popular assertion library for writing Angular unit tests. The document provides examples of how to set up Karma and write unit tests using Jasmine's matcher methods and expectations. It emphasizes the importance of writing code in a testable way by isolating dependencies and single responsibilities.
The document discusses best practices, tips, performance, and debugging strategies for Protractor, an end-to-end testing framework for AngularJS applications. It addresses common problems like unknown window sizes, fragile tests due to small HTML changes, and long test run times. Solutions include setting the window size before tests, using page objects to abstract the HTML, enabling sharding to run tests in parallel, and integrating with IDEs for debugging. The tips are from Sergey Bolshchikov, a developer advocate and creator of resources for front-end developers.
This document provides information on setting up and running tests with Protractor. It discusses installing Node.js, Protractor and other dependencies. It also includes samples of Protractor configuration files for running tests on different browsers, in parallel and headless mode. References are provided at the end for Protractor tutorials, documentation and code samples.
Bring stories to life using BDD (Behaviour driven development)Srikanth Nutigattu
This document discusses adopting a user-centric approach to software development using Behavior-Driven Development (BDD). It notes that traditional software approaches involved separate business analysis, requirements gathering, development, and testing phases, whereas BDD aims to satisfy customers through early delivery of valuable software with business and development teams working together daily. BDD captures user stories and scenarios to specify desired software behavior and enhances collaboration between roles. Choosing a BDD framework depends on the application stack to facilitate shared tooling and skills across teams.
Protractor is an end-to-end testing framework for AngularJS applications that combines tools like NodeJS, Selenium, Jasmine, and Mocha. It has customizations from Selenium to easily create tests for AngularJS apps and speeds up testing by reducing waits. Protractor allows organizing tests with Jasmine for both unit and functional testing and runs tests on real browsers. Setting up Protractor requires installing Node.js, Protractor, and Selenium Webdriver along with creating a spec file for tests and a conf file for configuration.
ProtractorJS for automated testing of Angular 1.x/2.x applicationsBinary Studio
Presentation for "Meet for IT: Learning to test. Testing to learn" by Oleksandr Khotemskyi (QA Team Lead at Lohika)
video: https://youtu.be/VC0q1VXv9ZQ?t=13
We're now living the golden age of JavaScript. An increasingly number of people are seeing it as a complete language. Therefore, agile development practices are now being adapted and applied to JavaScript code production. However, there has been a lack of support tools in the JS ecosystem, compared to what can be found on other platforms.
A year ago, native BDD solutions similar to Cucumber were almost inexistant. Yet the need for it was manifest. It didn't take me long before I proposed and started hacking on the port of our favourite cucurbitaceae.
Cucumber.js is a native JavaScript implementation of Cucumber. It is a strict port that can run on any JavaScript environment. It runs on Node.js as well as within any browsers, making it virtually serviceable against everything producing JavaScript and HTML (Node.js, Ruby on Rails, PHP, .Net, etc.).
This is an introduction to the young Cucumber.js. After briefly exposing the history and goals of the project, I'll demonstrate how to write features, step definitions, hooks, support code, how to invoke it from both Node.js and browser environments.
Presented at:
- CukeUp! 2012: http://skillsmatter.com/podcast/agile-testing/cucumber-js-cuke-up-your-javascript
- LNUG June 2012: http://lnug.org/
The LAZY Developer's Guide to BDD (with Cucumber)Tze Yang Ng
This document provides a summary of behavior-driven development (BDD) and how to implement it using Cucumber. It discusses BDD principles like focusing on behaviors, delivering stakeholder value, and ensuring enough is done without overengineering. Cucumber is introduced as a tool that allows non-technical stakeholders to express application features in plain text for documentation, examples, and testing. The document outlines setting up Cucumber with features files, step definitions, and integrating it with a target application using a driver like Selenium.
The document discusses end-to-end testing of AngularJS applications using Protractor. It provides an overview of how Protractor works, basic configurations, creating tests, the WebDriver control flow, and a style guide for writing Protractor tests. Some best practices covered include using Page Objects to encapsulate page elements, making tests independent, and navigating to pages before each test. The presentation also addresses testing non-AngularJS apps and takes questions.
Automated Testing with Cucumber, PhantomJS and SeleniumDev9Com
The document discusses Behavior Driven Development (BDD) using Cucumber, Selenium, and PhantomJS. Cucumber uses a natural language syntax called Gherkin to write automated acceptance tests. Selenium is used to automate interactions with a web browser, while PhantomJS allows running those tests headlessly on a CI server without requiring a graphical browser. The example project demonstrates how Cucumber features written by PMs/BAs can be linked to Selenium step definitions to test a web application.
Protractor is an end-to-end test framework for AngularJS applications built on top of Selenium WebDriver. It runs tests against an application in a real browser, interacting with it as a user would. Protractor provides AngularJS-specific APIs and tools to help with debugging on top of WebDriverJS. Functional tests are the foundation of quality but should be isolated and decoupled from the UI using patterns like page objects. Protractor is ready to use today for testing AngularJS applications.
The document discusses setting up and running end-to-end tests with Protractor. It includes instructions on installing Protractor and related packages, configuring the test framework, writing tests using Mocha and Chai, and tips for running specific tests and managing test data across examples. Code snippets show examples of defining tests to validate page content and links on page load.
Вы пишете е2е тесты для вашего приложения иони даже работают, но интуиция подсказывает что не так. При каждом незначительном изменении html, приходится править тесты. Со временем их тяжело читать, дописывать и поддерживать. Звучит знакомо?
В этой лекции мы обсудим примеры и практики, которые решаю эти и многие другие проблемы. Эти практики - результат, накопленный за несколько лет написания и поддержки более тысячи тестов в WIX среди разных команд.
The presentation on Protractor Cucumber BDD Approach was done during #ATAGTR2017, one of the largest global testing conference. All copyright belongs to the author.
Author and presenter : Rajat Acharya
Continuous Testing With React Storybook & WebdriverIOJosh Cypher
This document summarizes Josh Cypher's presentation on continuous testing with React Storybook and WebdriverIO. It discusses using Storybook for UI development and testing React components in isolation. WebdriverIO is recommended for end-to-end acceptance testing through a real browser. A testing pyramid is presented with unit tests at the bottom and end-to-end tests at the top. Continuous testing should happen at all stages of development through unit, component, snapshot, and acceptance tests to catch errors early and reduce risks.
Writing useful automated tests for the single page applications you buildAndrei Sebastian Cîmpean
How to approach testing if you are building a modern single page application. I try to emphasize that integration testing is the way to go and that developers should consider the tests as part of the system and spend time to maintain them.
High Performance Software Engineering TeamsLars Thorup
Based on my experiences building high performance engineering teams, this presentation focuses on the technical practices required. These practices centers around automation (build, test and deployment) and increased collaboration between Engineering and QA (TDD, exploratory testing, prioritization, feedback cycles).
The document discusses the principles and practices of continuous delivery in an agile context. It emphasizes automating the entire software delivery process from code commits through deployment to production to minimize risks and ensure fast, reliable software updates. This includes having automated tests, continuous integration, monitoring systems, and the ability to rollback changes. It also stresses the importance of collaboration across teams to establish a shared goal of delivering value to customers through working software.
Beyond TDD: Enabling Your Team to Continuously Deliver SoftwareChris Weldon
Many project teams have adopted unit testing as a necessary step in their development process. Many more use a test-first approach to keep their code lean. Yet, far too often these teams still suffer from many of the same impediments: recurrent integration failures with other enterprise projects, slow feedback with the customer, and sluggish release cycles. With a languishing feedback loop, the enterprise continues to put increasing pressure on development teams to deliver. How does an aspiring agile team improve to meet the demands of the enterprise?
Continuous integration is the next logical step for the team. In this talk, you’ll learn how continuous integration solves intra and inter-project integration issues without manual overhead, the value added by continuous integration, and how to leverage tools and processes to further improve the quality of your code. Finally, we discuss the gold standard of agile teams: continuous deployment. You’ll learn how continuous deployment helps close the feedback loop with your customers, increases visibility for your team, and standardizes the deployment process.
Kris Buytaert gave a talk on DevOps at DrupalCon Munich in 2012. He discussed how the silos between development and operations created problems, and how the DevOps movement aims to break down those barriers through automation, collaboration, and continuous delivery. DevOps is not defined by specific tools but by cultural and process changes like integrating operations work into the entire software lifecycle from early on. The talk covered challenges like managing data and environments across different stages and how tools like Vagrant and configuration management can help address them.
You only have to change on thing to do the DevOps, everythingKen Mugrage
In this talk I point out several areas of focus when making the transition to a DevOps culture, and point out why it’s important that you change everything.
Quality Assurance: What is it and what are the Business Benefits?Sparkhound Inc.
This is a Beginner/Intermediate -evel presentation. Sparky Lyle Hutson discusses some of the basics about what QA is capable of - both for waterfall and agile methodology. He discusses building a test matrix and its effectiveness with multiple checkpoints throughout a given testing session, as well as simple QA tricks.
The document discusses quality assurance and the role of quality analysts. It defines quality assurance as ensuring an expected level of quality throughout the development lifecycle. Quality analysts, or QAs, test applications to find issues early and ensure minimal risks. The document outlines when QAs become involved in waterfall and agile development methods, and highlights some benefits of investing in quality assurance like mitigating risks and catching bugs early.
The document discusses quality assurance and the role of quality analysts. It defines quality assurance as ensuring an expected level of quality throughout the development lifecycle. Quality analysts, or QAs, test applications to find issues early and ensure minimal risks. The document outlines when QAs become involved in waterfall and agile development methods, and highlights some benefits of investing in quality assurance like mitigating risks and catching bugs early.
Lean Software Development by DeKnowledge.net
-----------------------------------------------------------------------------
DeKnowledge is the leading provider of project management certifications training workshops and consultancy. In addition to our open enrollment certifications training workshops, we also offer a wide range of management, leadership and technical based courses that can be tailored to fit your organization's needs.
With offices in the USA, The Netherlands and India, we work with clients in USA, Europe, South Africa and Asia. Our mission is to help companies manage their projects/programs more effortlessly and efficiently. We do this by collaborating with our clients in the areas of portfolio/program and project management training workshops and consultancy.
Testing Hourglass at Jira Frontend - by Alexey Shpakov, Sr. Developer @ Atlas...Applitools
Alexey Shpakov presents on testing in Jira Frontend. He discusses the testing pyramid with unit, integration, and end-to-end tests. He then introduces the concept of a "testing hourglass" which adds deployment and post-deployment verification to the pyramid. Key aspects of each type of test are discussed such as using feature flags, monitoring for flaky tests, and gradual rollouts to reduce risk.
A Comprehensive Guide to Conducting Test Automation Using Appium & Cucumber o...flufftailshop
The widespread use of mobile applications in our daily lives has created a demand for seamless integration and reliable performance. Modern tech-savvy users expect mobile apps to solve their problems seamlessly and without fail.
Don't hate, automate. lessons learned from implementing continuous deliverySolano Labs
This presentation on Continuous Delivery is from the November 2013 Automated Testing San Francisco meetup that took place at Constant Contact. The author/presenter is Matt Wilson, CTO of Lab Zero. Matt has advised clients at various industries including consumer brands, non-profits, start-ups, and financial services on Agile development, web application development, and other technology leadership challenges. This overview on Continuous Delivery highlights some of the best practices that Lab Zero has distilled, based on their many client engagements.
---
About Matt Wilson:
Matt is an enthused agile developer, architect, and consultant. He enjoys building elegant web services in Ruby. He believes that high-fives are underrated and measures the success of his day by how many he's seen.
Prior to joining Lab Zero, Matt's work history includes: Co-founder/Architect at Earfl.com, Architect at Kodak Gallery, Developer at Westwave Communications, Engineer at Motorola, and Developer at Coldwell Banker.
About Lab Zero:
Lab Zero Innovations, Inc. provides web application development and technology leadership consulting. Our client relationships include staff augmentation, pure software development, project management, system integration, advisor/leadership roles. Contact us about your next project.
Observation: Automated testing is not used with legacy projects.
My goal is to encourage you to start testing. Today I will present you the HOW TO part using CasperJS.
The document discusses Test Driven Development (TDD). It describes the TDD cycle of writing an initially failing test, then code to pass the test, and refactoring. It proposes adopting TDD practices like writing tests for components before code and using continuous integration. It also discusses using code analysis tools in integration and avoiding tests sharing developer blind spots. Shortcomings discussed are difficulty testing interfaces and risk of false security from tests.
These slides mark the goals that we'd like to accomplish defining a QA team which eliminates the frictions with development teams. How much is achieved? Well, it's on our plans to follow it. But we do not know if we'll be able to make it possible
This document provides an overview of Cucumber, a behavior-driven development framework. It discusses what BDD is, the benefits it provides like usability, fewer defects, and living documentation. Popular BDD tools like Cucumber, Jasmine and JBehave are mentioned. Cucumber is introduced in more detail, explaining how it executes scenarios using a Given, When, Then format and supports multiple programming languages. Hands-on examples demonstrate features like data and table-driven execution, background, hooks, tags and reports. Suggested additional reading materials on BDD and Cucumber are also provided.
Unit testing involves testing individual units or components of code, such as classes or methods, in isolation from the rest of the code base. A unit test asserts certain conditions or tests for specific behaviors and returns a pass/fail result. The purpose of unit testing is to validate that each piece of code works as intended, allowing code to be refactored with confidence and problems to be identified early. Best practices for unit testing include writing tests for new code, designing code for testability, and following an arrange-act-assert structure. Tests should be fast, isolated, and clearly named. Unit testing promotes code quality, documentation, and easier refactoring.
Similar to Automated Testing in Angular Slides (20)
This document provides an overview of serverless computing and introduces serverless frameworks for ClojureScript including CLJS-Lambda and Serverless-Cljs. It defines serverless as exposing single functions that are run on shared servers and paid for only by execution time. Recommended resources on serverless architectures and the AWS serverless page are provided. The document discusses JVM options for ClojureScript lambdas and introduces lein plugins and templates for building, testing, and deploying serverless ClojureScript functions to AWS Lambda including commands for building, deploying, and invoking functions.
10 Tips For Serverless Backends With NodeJS and AWS LambdaJim Lynch
The document provides 10 tips for building serverless backends with Node.js and AWS Lambda. It discusses how serverless architectures are cheaper and easier to manage than traditional servers. It then outlines each tip which includes how to create "Hello World" functions, pass data to Lambda functions, set up REST APIs, secure functions, send emails/texts, schedule functions, view logs, add additional Node.js libraries, and use Lambda with IoT devices.
This document provides an overview of the Angular CLI and how to get started with it. It discusses how to install the Angular CLI, generate an initial project using the ng new command, and an overview of the file structure and common commands like ng serve, ng test, and ng build. It also briefly touches on generating components, services, pipes and more using the ng generate command.
ACEP Magazine edition 4th launched on 05.06.2024Rahul
This document provides information about the third edition of the magazine "Sthapatya" published by the Association of Civil Engineers (Practicing) Aurangabad. It includes messages from current and past presidents of ACEP, memories and photos from past ACEP events, information on life time achievement awards given by ACEP, and a technical article on concrete maintenance, repairs and strengthening. The document highlights activities of ACEP and provides a technical educational article for members.
Low power architecture of logic gates using adiabatic techniquesnooriasukmaningtyas
The growing significance of portable systems to limit power consumption in ultra-large-scale-integration chips of very high density, has recently led to rapid and inventive progresses in low-power design. The most effective technique is adiabatic logic circuit design in energy-efficient hardware. This paper presents two adiabatic approaches for the design of low power circuits, modified positive feedback adiabatic logic (modified PFAL) and the other is direct current diode based positive feedback adiabatic logic (DC-DB PFAL). Logic gates are the preliminary components in any digital circuit design. By improving the performance of basic gates, one can improvise the whole system performance. In this paper proposed circuit design of the low power architecture of OR/NOR, AND/NAND, and XOR/XNOR gates are presented using the said approaches and their results are analyzed for powerdissipation, delay, power-delay-product and rise time and compared with the other adiabatic techniques along with the conventional complementary metal oxide semiconductor (CMOS) designs reported in the literature. It has been found that the designs with DC-DB PFAL technique outperform with the percentage improvement of 65% for NOR gate and 7% for NAND gate and 34% for XNOR gate over the modified PFAL techniques at 10 MHz respectively.
6th International Conference on Machine Learning & Applications (CMLA 2024)ClaraZara1
6th International Conference on Machine Learning & Applications (CMLA 2024) will provide an excellent international forum for sharing knowledge and results in theory, methodology and applications of on Machine Learning & Applications.
Embedded machine learning-based road conditions and driving behavior monitoringIJECEIAES
Car accident rates have increased in recent years, resulting in losses in human lives, properties, and other financial costs. An embedded machine learning-based system is developed to address this critical issue. The system can monitor road conditions, detect driving patterns, and identify aggressive driving behaviors. The system is based on neural networks trained on a comprehensive dataset of driving events, driving styles, and road conditions. The system effectively detects potential risks and helps mitigate the frequency and impact of accidents. The primary goal is to ensure the safety of drivers and vehicles. Collecting data involved gathering information on three key road events: normal street and normal drive, speed bumps, circular yellow speed bumps, and three aggressive driving actions: sudden start, sudden stop, and sudden entry. The gathered data is processed and analyzed using a machine learning system designed for limited power and memory devices. The developed system resulted in 91.9% accuracy, 93.6% precision, and 92% recall. The achieved inference time on an Arduino Nano 33 BLE Sense with a 32-bit CPU running at 64 MHz is 34 ms and requires 2.6 kB peak RAM and 139.9 kB program flash memory, making it suitable for resource-constrained embedded systems.
Advanced control scheme of doubly fed induction generator for wind turbine us...IJECEIAES
This paper describes a speed control device for generating electrical energy on an electricity network based on the doubly fed induction generator (DFIG) used for wind power conversion systems. At first, a double-fed induction generator model was constructed. A control law is formulated to govern the flow of energy between the stator of a DFIG and the energy network using three types of controllers: proportional integral (PI), sliding mode controller (SMC) and second order sliding mode controller (SOSMC). Their different results in terms of power reference tracking, reaction to unexpected speed fluctuations, sensitivity to perturbations, and resilience against machine parameter alterations are compared. MATLAB/Simulink was used to conduct the simulations for the preceding study. Multiple simulations have shown very satisfying results, and the investigations demonstrate the efficacy and power-enhancing capabilities of the suggested control system.
A review on techniques and modelling methodologies used for checking electrom...nooriasukmaningtyas
The proper function of the integrated circuit (IC) in an inhibiting electromagnetic environment has always been a serious concern throughout the decades of revolution in the world of electronics, from disjunct devices to today’s integrated circuit technology, where billions of transistors are combined on a single chip. The automotive industry and smart vehicles in particular, are confronting design issues such as being prone to electromagnetic interference (EMI). Electronic control devices calculate incorrect outputs because of EMI and sensors give misleading values which can prove fatal in case of automotives. In this paper, the authors have non exhaustively tried to review research work concerned with the investigation of EMI in ICs and prediction of this EMI using various modelling methodologies and measurement setups.
Presentation of IEEE Slovenia CIS (Computational Intelligence Society) Chapte...University of Maribor
Slides from talk presenting:
Aleš Zamuda: Presentation of IEEE Slovenia CIS (Computational Intelligence Society) Chapter and Networking.
Presentation at IcETRAN 2024 session:
"Inter-Society Networking Panel GRSS/MTT-S/CIS
Panel Session: Promoting Connection and Cooperation"
IEEE Slovenia GRSS
IEEE Serbia and Montenegro MTT-S
IEEE Slovenia CIS
11TH INTERNATIONAL CONFERENCE ON ELECTRICAL, ELECTRONIC AND COMPUTING ENGINEERING
3-6 June 2024, Niš, Serbia
3. WHY USE AUTOMATED TESTING AT ALL?
IF YOU DON’T HAVE AUTOMATED TESTS…
▸ Refactoring becomes dangerous since you can break
something and not be alerted of it.
▸ The team must rely on heavily on manual testing to ensure
quality which is expensive and lengthens each iteration.
▸ Anyone reading your code has nothing to help him or her
understand the code besides that source code itself.
▸ Every push to production leaves you with fear and worry in
the back of your mind that something might go wrong.
4. “OUR HIGHEST PRIORITY IS TO SATISFY
THE CUSTOMER WITH EARLY AND
CONTINUOUS DELIVERY OF VALUABLE
SOFTWARE”
#1 Principle of Agile Manifesto 12 Principles
IT ALL COMES BACK TO THIS
5. MANUAL TESTING
▸ Can you think of a manual test that can’t be automated?
▸ Manual Testing is the Devil!
▸ Quickly becomes expensive, error prone, time consuming…
▸ Don’t rely only on “____ serve” for development because
then you need to test manually!
▸ Used only for exploratory / usability testing and
should NOT be a step in the deployment process.
AVOID IT!
9. PAGE OBJECTS
▸ These are the mysterious .po.js files.
▸ They allow you to separate the DOM selection code from
the core test logic.
▸ Existed way before Protractor was even a thing. Tons of
info has been written on the web about page objects.
▸ Example:
KEEP YOUR UI TESTS MAINTAINABLE!
10. PROTRACTOR IS AWESOME!
▸ Test on virtually any browser via Sauce Labs!
▸ Allows you to control Selenium WebDriver with friendly,
JavaScript API.
▸ Tip: Start with functional testing of user interactions
and flow through the app.
▸ Keep it real! Instead of mocking backend services, just
run your tests on the real app and call it e2e testing too!
WE ARE SO LUCKY.
11. TEST ON ALL THE BROWSERS WITH SAUCE LABS!
ALL THE THINGS!
12. PROTRACTOR REPORTS
Install the package:
And then add this to your protractor config file
exports.config object:
Then on every
run you’ll get a
generated
report with
screenshots!
FOR WHEN YOU CARE WHAT ACTUALLY HAPPENED
18. IF YOU WANT TO REFACTOR,
THE ESSENTIAL PRECONDITION
IS HAVING SOLID TESTS.
Martin Fowler
author of Refactoring: Improving the Design of Existing Code
19. TDD: WHAT IS IT?
▸ TDD is all about writing unit tests for your source code.
▸ When you write the failing test first and then make it pass
with source code you can be confident that the test is
really covering the piece of functionality that it should.
▸ Ideally you should avoid writing testless lines of code.
▸ Write the tests first, inventing the names of controllers,
services, and methods in your tests. Then generate them
(or create them by hand), and implement them in a way
that makes the tests pass.
LET THE TESTS DRIVE THE DEVELOPMENT (DUH)
20. WHY IS TDD SO AWESOME?
▸ Unit tests can expose runtime errors immediately after
every change of the code which helps to keep quality high
and prevent regression.
▸ Seeing a unit test fail, making a change in the source, and
seeing it pass helps show that the test is indeed checking
what it should.
▸ You don’t have to “go in after you’re done” and add in
unit tests.
▸ It encourages prolific refactoring with confidence.
TDD: YOU SHOULD LOVE IT
▸ You appreciate the importance of DELETING code.
21. TIPS FOR TDD & UNIT TESTING
▸ TDD is hard. Getting into the right mindset comes with practice.
▸ Try “Reverse TDD” (green-red-green-refactor) or “Transplant TDD”.
▸ Use mocks and spies. Check only one thing per test.
▸ Imagine testing each of your Angular objects in a black hole in
outer space separately from the rest of the application.
▸ Don’t worry about the UI details. Focus on testing the functions,
logic, and calculations of your source code.
▸ Focus on explicitly calling your “public methods” which in turn will
use the private methods to do it’s work.
22. THE HOLE IN PURE TDD
▸ You can sometimes find that it’s unclear “what test to write
next”.
▸ TDD Tests only that that software is free of errors but doesn’t
necessarily test that it provides real business value.
▸ It’s unclear how or when ui testing tools like Protractor fit
into the TDD development cycle.
▸ It says nothing about how to actually turn the requirements
into unit tests.
WHAT’S MISSING WITH TDD?
23. WOULDN’T IT BE NICE IF:
▸ we could save our requirements in source control also have them
accessible, readable, and easily understandable for all
stakeholders?
▸ the requirements were able to be run against our
codebase quickly and easily, recording which ones passed
and which ones failed?
▸ recordings could be visualized in a report similar to a
code coverage report but for show if our requirements
tests are passing?
IF ONLY WE HAD TDD FOR OUR REQUIREMENTS
25. TERMS THAT ALL REALLY REFER TO THIS SAME IDEA:
▸ Specification by Example
▸ Behavior Driven Development
▸ Acceptance-Test Driven Development
▸ Agile Acceptance Testing
WHAT SHOULD WE CALL IT?
29. GHERKIN
▸ Meant to be easily readable by non-programmers.
▸ Aids in building a common understanding of the requirements
between all parties and is accessible to non-programmers.
▸ Becomes incredibly nice as documentation and progress
reporting once the project begins.
▸ Meant to be written during a “Three Amigos” meeting.
30. Scenario: eat 5 out of 12
Given there are 12 cucumbers
When I eat 5 cucumbers
Then I should have 7 cucumbers
31. Scenario: Adding items to basket
Given I have no items in my shopping cart.
When I add 2 pumpkins
And remove two pumpkins
Then I should no items in my shopping cart.
32. FOR TEAMS PRACTICING BDD, THE
REQUIREMENTS AND THE EXECUTABLE
SPECIFICATIONS ARE THE SAME THING.
John Ferguson Smart
from BDD In Action
33. OK... BUT HOW IS AN
ENGLISH SENTENCE
“EXECUTED”?
A. STEP DEFINITIONS
34. STEP DEFINITIONS
▸ Uses a Given-When-Then syntax which separate the test logic into setup
code, action code, and assertion code, respectively..
▸ The Gherkin is mapped to a
step definition function that
uses a regex to match the
Gherkin text.
▸ These functions then
implement what the Gherkin
says should happen and
checks these business
requirements against the
source code.
MAPPING GHERKIN STEPS TO JAVASCRIPT FUNCTIONS
35. BUT HOW DOES ONE SIMPLY
“IMPLEMENT A STEP DEFINITION”
IN ANGULARJS?
36. UNDERSTANDING CUCUMBERJS
▸ Instead of running the acceptance tests through cucumber
itself, we can “cucumberize” or existing test runners.
▸ The most common JavaScript acceptance test running
framework is called, “Cucumber-JS”.
▸ Running CucumberJS itself might be fine for a NodeJS
project, but AngularJS testing requires special setup that
CucumberJS does not know how to do.
37. CUCUMBERIZING YOUR TEST RUNNERS
▸ For Karma I recommend, “karma-cucumber-js”:
https://github.com/eugene-sea/karma-cucumber-js
▸ Karma and Protractor both know how to execute gherkin.
▸ Both have a “frameworks” option that gets changed
▸ For Protractor, check out “protractor-cucumber-framework”:
https://github.com/mattfritz/protractor-cucumber-framework
39. RUNNING CUCUMBERIZED PROTRACTOR TESTS
▸ You can also set up gulp / grunt tasks for acceptance tests.
▸ Tell Protractor to only
look for the files with
BDD suffixes
like .feature
or .step.js
▸ Run the Protractor executable and pass in your config file:
40. CUCUMBERIZING KARMA
‣ Notice that this project uses a slightly different syntax
from Protractor step definitions:
▸ I recommend “karma-cucumber-js” (by eugene-sea) and not
“karma-cucumberjs” (works with newer versions on cucumberjs).
41. WRITING KARMA STEP DEFINITIONS
▸ The Then is where you do the assertion that what you
expected to happen did happen.
▸ The Given is similar to your “beforeEach” regular unit
tests. It is where you can inject Angular objects and create
mocks.
▸ The When is where you do some action, in this case
normally calling a public method of some controller,
service, etc.
42. THE CUCUMBER “WORLD”
▸ Cucumber has the concept of a “World object” that is
somewhat of a global object for your acceptance tests.
▸ You can set frameworks like chai to the World object,
allowing you to use chai API in your step definitions.
▸ Depending on your cucumber framework it’s either an
object or a function that you can implement.
▸ It’s purpose is to allow you to define “utility properties”
that can be used in step definitions.
43. WHY YOU SHOULD ALSO STILL USE YOUR NON-
CUCUMBERIZED TEST RUNNERS
▸ If you’re worried about having two separate code coverage
reports, you can combine them with “Instanbul-combine”.
▸ Use cucumberized karma when you don’t need the
UI to test the BUSINESS CASE of the scenario.
▸ It’s important to be able to increase your code coverage
without needing to write “boring scenarios”.
45. GOOD REPORTS ARE KEY TO SUCCESS
▸ Cucumber reports allow you to see the progress of the
application at any point in time.
▸ The reports should be seen as incredibly useful.
▸ Reports are all just-in-time generated (ideally from a
build server) giving everyone up-to-date reports
available at any time without the devs ever needing to
“write documentation”.
▸ Code coverage report lets you know what has’t been
covered by unit tests.
YOUR LIVING DOCUMENTATION!
▸ Great for the BAU team trying to understand your code.
46. THE MOST SUCCESSFUL TEAMS DISCOVERED
THE LONG-TERM BENEFIT ON
IMPLEMENTING SPECIFICATION BY EXAMPLE
COMES FROM LIVING DOCUMENTATION.
Gojko Adzic
from “Specification by Example”
47. A LOT OF PREPARATION GOES A LONG WAY
▸ But it’s worth it!
▸ Jenkins pipeline to run all of these tests, hosts the
reports, and deploy the final build.
▸ Creating a cucumberized Protractor config file.
▸ Creating a cucumberized Karma config file.
▸ Learning and understanding gherkin / step definitions.
CAN WE START YET?
▸ More complicated file globbing patterns.
49. BDD WITHOUT CUCUMBER
▸ Some downsides to not cucumberizing your runners
include:
▸ You can still practice some form of Behavior Driven
Development even without cucumberized test runners.
▸ You can still have “Three Amigos” conversations about the
requirements and even create Gherkin feature files without
executing them.
KEEP AN ACCEPTANCE TESTING MINDSET
1) You don’t get reports (ie living documentation).
2) You don’t know if your code passes or fails the scenarios.
3) You don’t have explicit step definition functions.
50. ADDITIONAL BENEFITS OF ACCEPTANCE TESTS
▸ Misunderstandings get thrashed out early.
▸ Better team communication and ubiquitous language.
▸ Requirements and code are always in sync
▸ Removes the manual testing bottleneck.
▸ JIT documentation for development and beyond.
IF YOU’RE STILL NOT CONVINCED
▸ It helps developers think more in the business domain
than just falling back to computer science patterns.
51. BUT WE DON’T HAVE TIME FOR TESTING
▸ Remind him that with the all of the rework, regression, and
manual testing it could easily take longer to build the
project without tests.
▸ Remind the boss that this is a long-term project, and the
reports increase in value as the project ages.
▸ The 99% perfect rule: Nobody wants 99% perfect
software. If it’s not bug-free then it’s not really finished.
▸ Is it that your team doesn’t have time, or is it that they just
don’t know how and no one wants to pair program on it?
BUILD IT QUICKLY VS BUILD IT FOR LONGEVITY
52. HIGH QUALITY -> HIGH PERFORMANCE
PERFORMANCE TESTING
▸ Manual performance testing available through Chrome
dev tools, WebPageTest, Google Pagespeed…
▸ Command line utility “Benchpress” that can be used for
getting stats on and benchmarking any web application.
▸ In general, favor automated performance tests for the
same reasons we automate our other tests.
▸ You could even host your benchpress report(s) on every
build as part of your living documentation!
53. WHERE DO I PUT ALL OF THESE FILES?
▸ Avoid parallel directory structures
or you might find yourself with
“scrolling like mad syndrome”.
▸ It usually makes sense to work
on one component at a time,
and it’s nice to have all the
things relating to that
component in one place.
DIRECTORY DIVING
54. IT’S “LIVING” DOCUMENTATION, SET IT LIVE!
THE IMPORTANCE OF HOSTING YOUR REPORTS
▸ Without hosting your reports at a url for everyone to see,
no one on your team can see the reports!
▸ Reports should NOT be generated and hosted manually.
Generating the reports (by running the tests) and hosting
them should be steps in your CI pipeline.
▸ As a CEO or business leader, if you can create a culture
that highly values and utilizes these three types of reports,
everything else will* fall into place.
▸ Access to up-to-date reports for non-programmers is
CRITICAL for them to do their job properly.