Testing for fun in production Into The Box 2018

Presentation about using Jenkins as an automation tool for deploying database objects and APEX Applications. Jenkins Pipelines are used and compared to Jenkins Jobs.

Airware's cloud automation team returns with a year’s worth of lessons learned, and 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. Topics Async / Await - an alternative to Webdriver’s built-in control flow. Limitations with control flow. Use Babel to write the latest ES6 JavaScript syntax. Custom reporter with screenshots from Sauce Labs. Parallel tests and accurate reporting. Type-safe JavaScript with Facebook’s Flow-type library. Robust visual diffs

** Update ** There is now an updated version of this implementation with Javascript Async/Await Recording - https://www.youtube.com/watch?v=BTpMB2-8qMM Slides - https://www.slideshare.net/MekSrunyuStittri/endtoend-test-automation-with-nodejs-one-year-later Abstract With the growing popularity of NodeJS, many companies have embraced its adoption and gone full stack. The next logical move is to have the test framework be on the same stack. Unfortunately, proven ways of implementing a Selenium framework in JavaScript are very limited and very much fragmented. Airware builds software and hardware for commercial drones; their cloud team ships code to production every week. In this talk, their cloud automation team will talk about: how they have built their Selenium framework with Node.js; the challenges of coming from a synchronous programming language like Java; lessons learned along this journey; and other technologies/tools used to complement testing their cloud and rolling out quality. Recording by New Relic and SauceLabs - https://www.youtube.com/watch?v=CqeCUyoIEo8

Code Examples Cut from Polyglot Automation talk given at QA Fest full video: https://www.youtube.com/watch?v=D4w8btYlbRY full presentation: http://www.slideshare.net/yashaka/polyglot-automation-qa-fest-2015

San Francisco Java User Group presents Chris Bedford who talks about: - How to write functional tests with Selenium (including explaining its IDE, architecture, RC, and alternatives like Canoo WebTest) - How to set up Selenium testing for web apps in continuous integration using Maven, Ant, Cargo, etc. - How to use Hudson for build server (brief overview) January 12, 2010 in San Francisco, CA http://www.sfjava.org/calendar/11982857/ Hosted by SUPINFO International University Sponsored by TEKsystems, Guidewire Software, Sun, O'Reilly, JetBrains, and Marakana. Video by Max Walker Organized by Marakana

Behavior-Driven Development and Acceptance Testing are heavily intertwined and in many aspects are one and the same. Both focus on starting at the outer layers of your application by concentrating on what matter to users; behavior. In this session/workshop we'll talk about how testing can be used both for specifying your application yet to be develop expected behavior and as accurate, running documentation that can be used to validate your stakeholder's acceptance criteria. We'll talk about the different types of testing and do a few hands-on exercises to flesh out a Rails application with RSpec and Capybara.

Selenide is simple and powerful in use wrapper-library over Selenium. But what the point just of shorter lines of code? In this talk we will see how to tame your webui mustang with Selenide and put it into fence of simple BDD stories with Easyb. We also consider pros and cons of the approach and compare to available alternatives.

The document discusses using Codeception for acceptance and functional testing. It introduces Codeception and the different types of testing including unit, functional, and acceptance testing. It then provides examples of writing functional tests for a login feature and acceptance tests using PhantomJS to test interactions on a real browser. Screenshots are included when acceptance tests fail to help debug issues.

В ходе доклада мы обсудим такие виды тестирования как: - юнит тестирование, - тестирование верстки, - e2e-тестирование, - тестирование производительности для FE Также мы коснемся таких фундаментальных вещей, как: - Что такое F.I.R.S.T - Где заканчивается ответственность разработчика и начинает - ответственность QA инженера - Как договариваться с бэкенд разработчиками - И конечно, почему тесты нужны.

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.

Presents BDD concepts and procedes along with introduction in JBehave as BDD implementation for Java.

Slides done for the talk on CodeCeption given during the April London Yii Meetup. The full screencast of the talk can be viewed here: https://www.youtube.com/watch?v=FclV9ML7bH4

Matt Chapman's presentation from DrupalCamp Brighton 2015 - see also the video at https://www.youtube.com/watch?v=vPpR1-MZmJo

Writing codes without mindset is a mess. Use one of React advanced patterns to enhance your code base by Higher Order Component. Please check demo repo for more detail: https://github.com/xJkit/trendmicro-fed-talk-pattern-hoc

A talk about my frontend testing framework: http://github.com/NeilCrosby/frontend-test-suite/tree/master

This document discusses behavior-driven development (BDD) and automation testing using the Cucumber framework. It provides an overview of BDD, what Cucumber is, how to perform BDD automation testing with Cucumber, and includes a live demo. The presentation is given by Trong Bui from KMS Technology and discusses their experience with BDD and Cucumber.

Presentation given at the Barcelona PHP Meetup, focuses around Continuous integration and continuous delivery with Codeception.

JavaOne presentation looking at the different tools available to JavaScript developers for debugging, performance and deployment

Java has been the historical leader for enterprise web application development. However, Node.js is rapidly gaining in popularity for developing mobile apps, APIs and web applications. Java and Node.js are complimentary tools for enterprise web application development and this session will highlight the strengths and complimentary nature of each. Presented at IBM InterConnect 2016

This document discusses automated acceptance testing for ASP.NET applications. It begins with a demonstration of using Selenium WebDriver to automate a Google search. The document then covers topics like the testing pipeline, challenges with real-world testing, focusing tests on solving specific pain points, and designing UI for testability. It emphasizes that UI tests should validate scenarios rather than individual actions and should focus on the most critical tests. The document also discusses tools, techniques, and strategies for testing databases, legacy systems, and more.

This document discusses improving automated web application testing. It begins with an introduction and agenda. Some key points: - Testing at Google expects test code quality to match production code quality. Tests must be maintainable and meet engineering standards. - The present focuses on Selenium/WebDriver automation best practices and things to avoid. Base classes and locator organization can help improve test robustness and maintainability. - The future may include more exploratory testing tools like WebTestingExplorer for automated exploratory testing. Overall the document provides guidance on using Selenium/WebDriver for web application testing in a best practices way, focusing on test code quality, maintainability, and anticipating future changes. It emphasizes organizing tests through

We often come across situations when: > We cannot figure out why our Selenium/Appium scripts fail during execution either locally or on CI. > We need to debug scripts locally while writing them but find debugging painful and slow Debugging the scripts is often the approach to fix them. What all different ways we can do it? I shared about some of the good practices I have used for debugging Selenium and Appium scripts

This document summarizes how to test Java web applications on mobile devices using Arquillian and Selenium. It describes setting up Android emulators, configuring the Arquillian extension for AndroidDriver, and writing sample unit and functional tests for a mobile web application using Page Object Model patterns and the WebDriver API. Tips are provided for debugging tests, capturing screenshots on failure, and integrating tests with Jenkins.

This document discusses integrating coded steps in functional tests using Telerik Test Studio. It begins with an agenda that includes getting started with test automation, recording and executing a test, why coded steps are needed, and a demo of coded steps with MS Test, databases, and file systems. Reasons for using coded steps include automating complex verifications, writing cleanup steps, setting up test environments, handling multiple data sources, and more. The presenter then demonstrates coded steps and discusses Telerik Test Studio pricing and resources.

Session Presented @IndicThreads Cloud Computing Conference, Pune, India ( http://u10.indicthreads.com ) ------------

This document discusses testing applications on Google App Engine. It covers using the App Engine testing framework to test the local datastore, authentication API, and memcache. It also provides an overview of Google Cloud Cover, which allows running test suites in parallel on the cloud. The document includes code examples for setting up local testing of the datastore using Spring and JUnit and testing the authentication API and memcache. It emphasizes that testing is important for correctness and refactoring and that App Engine has specific testing strategies to test core services locally.

This workshop is a hands-on training where a real Zend Framework application is used as an example to start improving QA using tools to test, document and perform software metric calculations to indicate where the software can be improved. I also explain the reports produced by a CI system.

TestComplete is an automated testing tool that supports testing of Windows, web, and web service applications. It provides functionality for automated, manual, load, and unit testing. TestComplete supports scripting languages like VBScript and C# and can integrate with version control systems. When compared to HP QuickTest Professional, TestComplete has advantages in areas like cost, support, scripting languages supported, and testing of technologies like .NET, web services, and manual testing. TestComplete also supports data-driven and keyword-driven testing through plugins.

This document discusses integrating test automation and code coverage for web service applications. It introduces Postman for calling web services and testing responses, and Jenkins for build automation and tracking test results over time. It then demonstrates setting up a test automation workflow using these tools on a sample Laravel application, including starting and stopping coverage collection, running tests from Postman and PHPUnit, and merging the results. Some best practices and philosophies around test automation and code coverage are also discussed.

The document introduces JavaScript testing and test-driven development (TDD). It discusses why software projects fail, challenges of testing JavaScript code, and how to use the Mocha and ChaiJS frameworks for TDD and behavior-driven development (BDD). It provides an example of writing unit tests for a user service function using TDD principles, implementing the code to pass the tests, and running the tests with Mocha. Benefits of testing code include short feedback cycles, high test coverage, documentation of specifications, and less time spent debugging.

This document discusses building automated acceptance tests that are stable and maintainable for continuous delivery. It emphasizes that developers should own acceptance testing by writing tests in the same way they write production code. This includes writing many unit and regression tests, optimizing for test execution, using immutable environments like Docker for isolation, and leveraging techniques like parallelization and separation of concerns with domain-specific languages. The document also provides examples of testing strategies, tools, and processes that can help achieve this goal.

Automated Developer Testing: Achievements and Challenges discusses automation in developer testing, including challenges such as generating better test inputs and oracles faster. Parameterized unit testing is proposed as a way to specify tests at a higher level of abstraction and allow test generation tools to automatically generate test inputs. Dynamic symbolic execution, as implemented in tools like Pex, is presented as an approach to automatically generating test inputs to achieve high code coverage by modeling tests as constraints and solving them.

The document discusses the new features of Java SE 6 including enhancements to web services, scripting, databases, desktop integration, monitoring and management, compiler access, pluggable annotations, desktop deployment, security, and performance. It provides code examples and explanations for many of the new features.

This document discusses using CommandBox and Docker to deploy real projects. It covers background on the development workflow and environments, benefits of Docker and CommandBox, code cleanup tools like CFLint and git hooks, serving apps with CommandBox, server monitoring with Prometheus, dynamic configuration, caching, session storage, logging with Elasticsearch and Kibana, load balancing with Kubernetes, data changes, scheduled tasks, and canary/blue-green deployments. The overall message is that CommandBox and tools can provide structure and simplify transitions to help teams succeed in deploying applications.

This document discusses using CommandBox and Docker to deploy real projects. It covers background on the development workflow and environments, benefits of Docker and CommandBox, code cleanup tools like CFLint and git hooks, serving apps with CommandBox, server monitoring with Prometheus, dynamic configuration, caching, session storage, logging with Elasticsearch and Kibana, load balancing with Kubernetes, data changes, scheduled tasks, and canary/blue-green deployments. The overall message is that CommandBox and tools can provide structure and simplify transitions to help teams succeed in deploying applications.

The document discusses introducing unit testing to legacy C++ code. It covers choosing a testing framework, writing initial tests and mocks, and various refactoring techniques like wrapping dependencies, extracting components, and adding non-intrusive C seams to facilitate testing. The goal is to incrementally make the code more testable while maintaining functionality through practices like test-driven development.

This presentation was given in GTAC 2008 (Also available on www.TestingGeek.com) and discuss the approach of using SVN commit hooks and batch files as continuous integration system.

Sami provided a beginner-friendly introduction to Amazon Web Services (AWS), covering essential terms, products, and services for cloud deployment. Participants explored AWS' latest Gen AI offerings, making it accessible for those starting their cloud journey or integrating AI into coding practices.

Explore the rapid development journey of TryBoxLang, completed in just 48 hours. This session delves into the innovative process behind creating TryBoxLang, a platform designed to showcase the capabilities of BoxLang by Ortus Solutions. Discover the challenges, strategies, and outcomes of this accelerated development effort, highlighting how TryBoxLang provides a practical introduction to BoxLang's features and benefits.