Deep dive into Apex Testing including an Intro, Types of Tests, Testing Async code, Testing external callouts, and using the Apex Replay Debugger to fix failed tests
How to Un-Flake Flaky Tests - A New Hire's ToolkitZachary Attas
This is my presentation for SeleniumConf India 2018. There are videos and animations not seen in this deck - sorry! You'll have to see the live presentation to get those.
Join us to learn the components required for building a good unit test that will keep your developers and applications from being blindsided, as well as some of the common Apex use cases like controllers and triggers. You'll also see how to handle trickier situations like HTTP callouts and asynchronous processing.
The document discusses Apex triggers and scheduler frameworks in Salesforce. It covers when to use before and after triggers, patterns for writing triggers, and batch size limits. It also discusses factory and abstraction patterns for writing triggers with multiple handlers. The document recommends keeping triggers simple with one trigger per object. It provides advantages of using a framework for triggers. Additionally, it covers scheduling batch Apex jobs, governor limits for batches, and calling serial batches by scheduling the next batch in the final method.
This document discusses strategies for keeping tests lean by focusing on tests that are valuable, reliable, and fast. It recommends evaluating each test to ensure it is testing the right thing and providing value. Tests should be isolated to avoid flakiness, monitored for failures, and run in parallel to speed up test runs. Headless testing and avoiding UI tests can also improve test run times. While there are tradeoffs, it is important that testing is a collaborative team effort.
Build Great Triggers Quickly with STP (the Simple Trigger Pattern)Vivek Chawla
The document introduces the Simple Trigger Pattern (STP) as a way to help developers quickly build great triggers that follow Apex trigger best practices. It begins by reviewing three key trigger best practices: having one trigger per object, keeping business logic out of triggers, and preventing trigger recursion using static variables. It then demonstrates the STP, which encapsulates these best practices into a template that provides a standardized structure for trigger handling. The STP code and documentation are available on GitHub to make it easy for developers to implement.
Getting your mobile test automation process in place - using Cucumber and Cal...Niels Frydenholm
Taking your mobile development process cycle, and the quality of the apps, from good to great.
See how focusing on automated tests can improve app quality, time to market and much more, and learn some best practices to avoid too much trouble getting started
Presented at Xamarin Evolve 2014
Dave Haeffner's Proven Method to Grading the Quality of Selenium TestsApplitools
** Watch Dave's full session recording here: https://youtu.be/IjGDxXCaDnE **
So you've written your fair share of Selenium tests.
Perhaps you've dabbled with Page Objects, Wait Strategies (aka Implicit and/or Explicit Waits), and you feel confident about your locators. Your test code might be in pretty good shape -- able to work reliably as time marches on and the application under test continues to evolve and your testing needs continue grow with it.
But how do you *know*? It's not like there is a quantitative way to measure this.
Or is there?
Watch Selenium expert Dave Haeffner as he steps through the core tenets of good test and page object design, locators, and a repeatable and quantitative approach for assessing your test code.
When you're done, you'll be able to see how your tests and page objects stack up, and what changes are needed to help them stand the test of time.
How to Un-Flake Flaky Tests - A New Hire's ToolkitZachary Attas
This is my presentation for SeleniumConf India 2018. There are videos and animations not seen in this deck - sorry! You'll have to see the live presentation to get those.
Join us to learn the components required for building a good unit test that will keep your developers and applications from being blindsided, as well as some of the common Apex use cases like controllers and triggers. You'll also see how to handle trickier situations like HTTP callouts and asynchronous processing.
The document discusses Apex triggers and scheduler frameworks in Salesforce. It covers when to use before and after triggers, patterns for writing triggers, and batch size limits. It also discusses factory and abstraction patterns for writing triggers with multiple handlers. The document recommends keeping triggers simple with one trigger per object. It provides advantages of using a framework for triggers. Additionally, it covers scheduling batch Apex jobs, governor limits for batches, and calling serial batches by scheduling the next batch in the final method.
This document discusses strategies for keeping tests lean by focusing on tests that are valuable, reliable, and fast. It recommends evaluating each test to ensure it is testing the right thing and providing value. Tests should be isolated to avoid flakiness, monitored for failures, and run in parallel to speed up test runs. Headless testing and avoiding UI tests can also improve test run times. While there are tradeoffs, it is important that testing is a collaborative team effort.
Build Great Triggers Quickly with STP (the Simple Trigger Pattern)Vivek Chawla
The document introduces the Simple Trigger Pattern (STP) as a way to help developers quickly build great triggers that follow Apex trigger best practices. It begins by reviewing three key trigger best practices: having one trigger per object, keeping business logic out of triggers, and preventing trigger recursion using static variables. It then demonstrates the STP, which encapsulates these best practices into a template that provides a standardized structure for trigger handling. The STP code and documentation are available on GitHub to make it easy for developers to implement.
Getting your mobile test automation process in place - using Cucumber and Cal...Niels Frydenholm
Taking your mobile development process cycle, and the quality of the apps, from good to great.
See how focusing on automated tests can improve app quality, time to market and much more, and learn some best practices to avoid too much trouble getting started
Presented at Xamarin Evolve 2014
Dave Haeffner's Proven Method to Grading the Quality of Selenium TestsApplitools
** Watch Dave's full session recording here: https://youtu.be/IjGDxXCaDnE **
So you've written your fair share of Selenium tests.
Perhaps you've dabbled with Page Objects, Wait Strategies (aka Implicit and/or Explicit Waits), and you feel confident about your locators. Your test code might be in pretty good shape -- able to work reliably as time marches on and the application under test continues to evolve and your testing needs continue grow with it.
But how do you *know*? It's not like there is a quantitative way to measure this.
Or is there?
Watch Selenium expert Dave Haeffner as he steps through the core tenets of good test and page object design, locators, and a repeatable and quantitative approach for assessing your test code.
When you're done, you'll be able to see how your tests and page objects stack up, and what changes are needed to help them stand the test of time.
The document discusses using examples and acceptance criteria to define requirements for software development. It recommends collaborating with business analysts, developers and testers to define examples that specify desired system behaviors in a clear and executable way. Automating acceptance tests based on these examples helps communicate requirements, verify functionality and allow for faster development cycles and deployments. Challenges include maintaining the tests and ensuring they don't become brittle. Strategies like minimizing end-to-end tests and focusing on key user journeys can help address these challenges.
Making the build self-testing is one of the best pratices of continuous integration. This was the main goal of this presentation, the work done in a REST API, using Symfony, phpspec, PHPUnit and Behat.
Automated acceptance tests (AATs) provide a way to specify and test a system's behavior in a way that is understandable to both technical and non-technical stakeholders. AATs should focus on major functionality and journeys through the system rather than individual stories. Page object patterns and other techniques can help make AATs more maintainable and readable. While AATs have benefits like earlier detection of bugs, their maintenance and speed make them best used selectively rather than for every user story.
This document outlines 10 commandments or best practices for Apex development on the Salesforce platform. The commandments are presented by two technical architects and include guidelines such as keeping code simple, avoiding queries and DML in loops, only using one trigger per object, focusing on test coverage, and writing meaningful tests. It is explained that these practices should generally be followed but are not strict rules, with the exception of bulkifying SOQL and DML queries. The document provides explanations for each recommendation to help developers write efficient, scalable and well-tested code.
Five Enterprise Development Best Practices That EVERY Salesforce Org Can UseSalesforce Developers
In any environment, non-existent or ad-hoc standards greatly contribute to technical debt. Join us as we explain why Salesforce's multi-tenant architecture and its platform and governor limits make managing technical debt in the App Cloud so critical. You'll discover five best-practices that can make an immediate impact on the maintainability and scalability of your org.
Test Automation and Innovation with Open Source ToolsMichael Palotas
This document discusses test automation at eBay using open source tools. It provides facts about eBay as a company and platform. The key points are:
1. eBay uses test automation with Selenium and open source tools to get early feedback from regression tests and reinvest time saved into more manual testing.
2. Their automation history started with homegrown solutions and moved to Selenium IDE, RC and now Selenium 2 along with a Selenium Grid for parallel testing across environments.
3. Using open source allows for faster innovation, independence, engagement with the community, and easier hiring. The potential risks include lack of support and competitors using the same tools.
4. Their test automation framework uses page objects, flow objects and a
Helps you to conform the Best Practices
Simply testing and maintaining the application logic is very easy
Assure Order of Execution
Prevent the Recursion
Error handling makes very easy
Strong software testing process is a key to project success. This presentation helps to understand better how to improve the process by automating routine API endpoints testing.
Reducing False Positives In Automated TestingQASource
In conjunction with Sauce Labs, QASource presented a webinar, "Reducing False Positives With Automated In Automated Testing". This slide deck summarizes the key points of the presentation. To view the complete webinar, visit: https://youtu.be/bi8hDBoZMPY
Subscribe to the QASource YouTube channel for future webinars and other engaging video content!
This document provides an overview and agenda for a session on debugging Apex triggers in Salesforce. It discusses common trigger problems like cascading triggers, governor limits, and null reference errors. It also outlines tools for working with triggers and provides examples of trigger use cases. The session aims to explore these common errors and how to solve them through code examples and using the Salesforce debug logs.
Episode 5 - Writing unit tests in SalesforceJitendra Zaa
The document provides an agenda for a session on writing unit tests in Apex. It discusses why unit tests are important in Apex, how to structure test classes, best practices for testing, and resources for learning more about Apex testing. The session demonstrates executing unit tests and techniques like accessing private members, running tests within limits, and creating test data. Attendees are encouraged to ask questions during the last 15 minutes.
From 0 to 100: How we jump-started our frontend testingHenning Muszynski
Everybody knows testing is important: it reduces bugs, it keeps you sane during refactorings, it increases the overall code quality etc…. We have all heard the countless arguments that speak for testing.
You probably know how the story continues: After developing for two years and ignoring all these (good) arguments we found ourselves in a gigantic code base without a single test. That we were horrified when thinking about adding tests to our code is an understatement. But we took a step back, thought about possible approaches and managed to get a very solid test coverage in a short period of time. And you can, too!
In this talk I present the state of the art for frontend testing (including but not limited to React testing). I am going to highlight different testing strategies and which mixture of tests works best for most applications. Additionally, I present tips and tricks we learned and applied at Doist. My goal is that everybody in the room can apply some take-aways in their daily work.
This talk was being held at #codetalkshh 2017
https://www.codetalks.de/en/2017/programm/from-0-to-100-how-we-jump-started-our-frontend-testing
When executing something synchronously, you wait for it to finish before moving on to another task. Asynchronously, you can move on before it finishes. Future methods, Queueable Apex, and Batch Apex allow asynchronous execution in Apex. Future methods are best for long-running methods or callouts. Queueable Apex allows job chaining and passing complex types. Batch Apex is best for large data volumes processed in batches. Continuations allow asynchronous callouts from Visualforce pages.
This document discusses automated software testing and test-driven development. It covers topics like the benefits of automated testing, dependency injection, testing with mocks, tips for testing, and things that make code difficult to test.
Introduction to using SpecFlow tool for testing REST API. For beginners that are at least a bit familiar with test automation, and gives some details and hints.
Slides used in workshop on "Getting started with Appium 2.0" at AppiumConf 2021
https://confengine.com/conferences/appium-conf-2021/proposal/15634/getting-started-with-appium-20
This document discusses the differences between tests and specifications, and how to write formal specifications for systems using TLA+. Tests check implementation details, while specifications check high-level design. TLA+ is introduced as a formal specification language that can be used to define abstract models of systems and check for complex bugs. Writing specifications in TLA+ helps validate system designs before implementation. Examples are provided showing how processes, variables, and properties can be specified in TLA+ to model behaviors like multi-device app installation.
This document introduces Canopy, an open source automated UI testing framework for web applications written in F#. Canopy uses a domain specific language with CSS selectors to perform actions like clicking, typing, waiting, and asserting results. It allows testers to create integration tests that complement unit testing and manual QA. The framework is demonstrated with a simple test. In conclusion, Canopy aims to make automated UI testing easy with minimal effort through its F# DSL and capabilities like screenshots and advanced selectors. More information is provided in the links at the end.
How to write better tests with Test Driven DevelopmentAlex Hoffman
The document discusses test-driven development (TDD) and how to use it to write better tests. TDD involves writing tests before production code to validate requirements in small iterations. Tests are written to initially fail, then production code is written to pass each test, ensuring all requirements are implemented. Following TDD principles helps developers think through code systematically and prevents unnecessary complexity.
6 Traits of a Successful Test Automation ArchitectureErdem YILDIRIM
This document discusses 6 traits of a successful test automation architecture:
1. Deciding which test levels to automate by considering factors like efficiency, expected vs unexpected scenarios, and intelligence vs repetitiveness.
2. Design principles for test automation including modularity, reusability, and separation of concerns.
3. Locator strategy which determines whether tests are flaky or robust, prioritizing unique, descriptive locators that are unlikely to change.
4. Methodology such as behavior driven development, test driven development, and continuous testing approaches.
5. Framework and language selection considering project dynamics and technologies. Examples mentioned are Geb, Spock, Groovy, and CodeceptJS.
6.
The document discusses using examples and acceptance criteria to define requirements for software development. It recommends collaborating with business analysts, developers and testers to define examples that specify desired system behaviors in a clear and executable way. Automating acceptance tests based on these examples helps communicate requirements, verify functionality and allow for faster development cycles and deployments. Challenges include maintaining the tests and ensuring they don't become brittle. Strategies like minimizing end-to-end tests and focusing on key user journeys can help address these challenges.
Making the build self-testing is one of the best pratices of continuous integration. This was the main goal of this presentation, the work done in a REST API, using Symfony, phpspec, PHPUnit and Behat.
Automated acceptance tests (AATs) provide a way to specify and test a system's behavior in a way that is understandable to both technical and non-technical stakeholders. AATs should focus on major functionality and journeys through the system rather than individual stories. Page object patterns and other techniques can help make AATs more maintainable and readable. While AATs have benefits like earlier detection of bugs, their maintenance and speed make them best used selectively rather than for every user story.
This document outlines 10 commandments or best practices for Apex development on the Salesforce platform. The commandments are presented by two technical architects and include guidelines such as keeping code simple, avoiding queries and DML in loops, only using one trigger per object, focusing on test coverage, and writing meaningful tests. It is explained that these practices should generally be followed but are not strict rules, with the exception of bulkifying SOQL and DML queries. The document provides explanations for each recommendation to help developers write efficient, scalable and well-tested code.
Five Enterprise Development Best Practices That EVERY Salesforce Org Can UseSalesforce Developers
In any environment, non-existent or ad-hoc standards greatly contribute to technical debt. Join us as we explain why Salesforce's multi-tenant architecture and its platform and governor limits make managing technical debt in the App Cloud so critical. You'll discover five best-practices that can make an immediate impact on the maintainability and scalability of your org.
Test Automation and Innovation with Open Source ToolsMichael Palotas
This document discusses test automation at eBay using open source tools. It provides facts about eBay as a company and platform. The key points are:
1. eBay uses test automation with Selenium and open source tools to get early feedback from regression tests and reinvest time saved into more manual testing.
2. Their automation history started with homegrown solutions and moved to Selenium IDE, RC and now Selenium 2 along with a Selenium Grid for parallel testing across environments.
3. Using open source allows for faster innovation, independence, engagement with the community, and easier hiring. The potential risks include lack of support and competitors using the same tools.
4. Their test automation framework uses page objects, flow objects and a
Helps you to conform the Best Practices
Simply testing and maintaining the application logic is very easy
Assure Order of Execution
Prevent the Recursion
Error handling makes very easy
Strong software testing process is a key to project success. This presentation helps to understand better how to improve the process by automating routine API endpoints testing.
Reducing False Positives In Automated TestingQASource
In conjunction with Sauce Labs, QASource presented a webinar, "Reducing False Positives With Automated In Automated Testing". This slide deck summarizes the key points of the presentation. To view the complete webinar, visit: https://youtu.be/bi8hDBoZMPY
Subscribe to the QASource YouTube channel for future webinars and other engaging video content!
This document provides an overview and agenda for a session on debugging Apex triggers in Salesforce. It discusses common trigger problems like cascading triggers, governor limits, and null reference errors. It also outlines tools for working with triggers and provides examples of trigger use cases. The session aims to explore these common errors and how to solve them through code examples and using the Salesforce debug logs.
Episode 5 - Writing unit tests in SalesforceJitendra Zaa
The document provides an agenda for a session on writing unit tests in Apex. It discusses why unit tests are important in Apex, how to structure test classes, best practices for testing, and resources for learning more about Apex testing. The session demonstrates executing unit tests and techniques like accessing private members, running tests within limits, and creating test data. Attendees are encouraged to ask questions during the last 15 minutes.
From 0 to 100: How we jump-started our frontend testingHenning Muszynski
Everybody knows testing is important: it reduces bugs, it keeps you sane during refactorings, it increases the overall code quality etc…. We have all heard the countless arguments that speak for testing.
You probably know how the story continues: After developing for two years and ignoring all these (good) arguments we found ourselves in a gigantic code base without a single test. That we were horrified when thinking about adding tests to our code is an understatement. But we took a step back, thought about possible approaches and managed to get a very solid test coverage in a short period of time. And you can, too!
In this talk I present the state of the art for frontend testing (including but not limited to React testing). I am going to highlight different testing strategies and which mixture of tests works best for most applications. Additionally, I present tips and tricks we learned and applied at Doist. My goal is that everybody in the room can apply some take-aways in their daily work.
This talk was being held at #codetalkshh 2017
https://www.codetalks.de/en/2017/programm/from-0-to-100-how-we-jump-started-our-frontend-testing
When executing something synchronously, you wait for it to finish before moving on to another task. Asynchronously, you can move on before it finishes. Future methods, Queueable Apex, and Batch Apex allow asynchronous execution in Apex. Future methods are best for long-running methods or callouts. Queueable Apex allows job chaining and passing complex types. Batch Apex is best for large data volumes processed in batches. Continuations allow asynchronous callouts from Visualforce pages.
This document discusses automated software testing and test-driven development. It covers topics like the benefits of automated testing, dependency injection, testing with mocks, tips for testing, and things that make code difficult to test.
Introduction to using SpecFlow tool for testing REST API. For beginners that are at least a bit familiar with test automation, and gives some details and hints.
Slides used in workshop on "Getting started with Appium 2.0" at AppiumConf 2021
https://confengine.com/conferences/appium-conf-2021/proposal/15634/getting-started-with-appium-20
This document discusses the differences between tests and specifications, and how to write formal specifications for systems using TLA+. Tests check implementation details, while specifications check high-level design. TLA+ is introduced as a formal specification language that can be used to define abstract models of systems and check for complex bugs. Writing specifications in TLA+ helps validate system designs before implementation. Examples are provided showing how processes, variables, and properties can be specified in TLA+ to model behaviors like multi-device app installation.
This document introduces Canopy, an open source automated UI testing framework for web applications written in F#. Canopy uses a domain specific language with CSS selectors to perform actions like clicking, typing, waiting, and asserting results. It allows testers to create integration tests that complement unit testing and manual QA. The framework is demonstrated with a simple test. In conclusion, Canopy aims to make automated UI testing easy with minimal effort through its F# DSL and capabilities like screenshots and advanced selectors. More information is provided in the links at the end.
How to write better tests with Test Driven DevelopmentAlex Hoffman
The document discusses test-driven development (TDD) and how to use it to write better tests. TDD involves writing tests before production code to validate requirements in small iterations. Tests are written to initially fail, then production code is written to pass each test, ensuring all requirements are implemented. Following TDD principles helps developers think through code systematically and prevents unnecessary complexity.
6 Traits of a Successful Test Automation ArchitectureErdem YILDIRIM
This document discusses 6 traits of a successful test automation architecture:
1. Deciding which test levels to automate by considering factors like efficiency, expected vs unexpected scenarios, and intelligence vs repetitiveness.
2. Design principles for test automation including modularity, reusability, and separation of concerns.
3. Locator strategy which determines whether tests are flaky or robust, prioritizing unique, descriptive locators that are unlikely to change.
4. Methodology such as behavior driven development, test driven development, and continuous testing approaches.
5. Framework and language selection considering project dynamics and technologies. Examples mentioned are Geb, Spock, Groovy, and CodeceptJS.
6.
The document provides information about benchmarking Apex code and declarative logic in Salesforce to measure CPU time usage. It discusses the CPU time limits that were introduced in Winter '14 and how they are calculated based on milliseconds allowed per record. Various techniques for benchmarking Apex code performance are demonstrated, such as measuring the cost of field assignments, serialization, and array iteration. Benchmarking declarative logic like workflows, processes, and validation rules is also covered. The document warns of the risks of CPU timeouts occurring from the combined impact of multiple applications, packages, or declarative components interacting on a record.
This document summarizes an upcoming Salesforce Apex Hours webinar on boosting app performance with Platform Cache. The webinar will be presented by Daniel Stange on January 4, 2020. It will cover key concepts of Platform Cache like caching strategies, data to cache, cache types and considerations. The presentation will also include a demo of implementing Platform Cache, including a read-through cache example. Attendees will learn how Platform Cache can significantly improve app performance and how to design caching strategies for their own implementations.
First Section:
Continuous Delivery as a software engineering approach.
(This is beneficial for Project Managers, DEVs & QAs.)
1. Projects Case Studies to explain why you should adopt Continuous Delivery.
2. Advantages & Reasons for releasing software more frequently.
3. How to make a Reliable / Production Ready Software.
4. Ingredients of Continues Delivery.
5. Tools/ approaches to choose while using Continues Delivery Methodology.
Second Section:
Technical side of Continuous Delivery.
(This is more beneficial for DEVs/ QAs than Project Managers.)
1. Testing a Software.
2. Measuring Code Quality / Analytic to visualize teams performances.
3. Tools: Code Syntax Checker, Testing Framework, Build Automation, Automated Reporting/ Analytic Dashboard.
4. Continuous Delivery Automation over Cloud using Travis CI - Live demonstration.
Third Section:
1. Sample Projects for audience to adopt right tools for development, testing & deployments.
2. Q&A.
-------------------------------------------------
By Waqar Alamgir http://waqaralamgir.tk
Want to learn how to use Selenium from the ground up? This presentation will show you how to start from nothing and build out a well factored, maintainable, resilient, and parallelized set of tests that will run locally, on a Continuous Integration server, and in the cloud. These tests will not only work well, but exercise relevant functionality that matters to the business.
Awesome Test Automation Made Simple w/ Dave HaeffnerSauce Labs
Learn how to build simple and powerful automated tests that will work on the browsers you care about, cover visual testing and functional regressions, and be configured to run automatically through the use of a continuous integration (CI) server.
testing is an important part of programming and software engineering. In this slide, I share insight on how to get started with writing tests in Django
This document discusses testing strategies for the iOS Sync Engine. It provides overall test stats, including that unit tests make up 80% of tests and integration tests make up 20%. The main testing strategy is to test against a fake backend called MockTransportSession, which provides advantages like speed, flexibility and independence over using stubs. MockTransportSession simulates the real backend by making fake requests, managing an internal database, and responding to requests. Future plans include splitting tests into smaller frameworks to reduce runtime, running tests on pull requests, and using record/replay to keep MockTransportSession in sync with the real backend.
Continuous Delivery & Testing Madrid AfterTestPeter Marshall
This document discusses continuous delivery and the testing challenges it presents. It describes a large financial institution's goal of delivering updates to their digital payment platform weekly. Initially they had a 9 month release cycle with many sequential test phases. The author proposed reducing features per release and incorporating more testing into development. This faced resistance from test managers concerned about quality and independent testing. Through education and demonstrations, the approach was modified to have functional testing after development and the culture shifted to prioritize automated testing and quality as everyone's responsibility.
QuerySurge, the smart data testing solution, QuerySurge, the smart data testing solution that automates data validation & testing of critical data, released the first-of-its-kind full DevOps solution for continuous data testing. The latest release, QuerySurge-for-DevOps, enables users to drive changes to their test components programmatically while interfacing with virtually all DevOps solutions in the marketplace. See how to implement a DevOps-for-Data solution in your delivery pipeline and improve your data quality at speed!
Testers will now have the capability to dynamically generate, execute, and update tests and data stores utilizing API calls. QuerySurge for DevOps has 60+ API calls with almost 100 different properties. This will enable a higher percentage of automation in your current data testing practice and a more robust DevOps for Data, or DataOps pipeline.
API Features Include:
- Create and modify source and target test queries
- Create and modify connections to data stores
- Create and modify the tests associated with an execution suite
- Create and modify new staging tables from various data connections
- Create custom flow controls based on run results
- Integration with virtually all build solutions in the market
QuerySurge for DevOps integrates with:
- Continuous integration/ETL solutions
- Automated build/release/deployment solutions
- Operations and DevOps monitoring solutions
- Test management/issue tracking solutions
- Scheduling and workload automation solutions
For more information on QuerySurge for DevOps, visit:
https://www.querysurge.com/solutions/querysurge-for-devops
Developer testing 101: Become a Testing FanaticLB Denker
In this workshop we will cover the methodologies and three basic levels of testing, then we will deep dive into how to use PHPUnit to achieve developer testing. The tests may not be the prettiest, most robust, or efficient, but you should leave the course with the ability and confidence to write tests for your code.
Topics include: xUnit framework basics and workflows, test classification, asserts, data driven testing, and an introduction to mocking.
This is a beginner course, but seasoned veterans may discover features they never knew.
This document summarizes the agenda and notes from a Cleveland Salesforce Developer Group meeting about testing. The meeting included presentations on closing the test automation gap and increasing testing velocity, as well as the return of H.O.T. (Happy Over Test) classes in Cleveland. Various announcements were also made about upcoming local and virtual events.
This document summarizes a presentation about testing APIs built with Laravel. It discusses testing API concepts in Laravel, including testing models, database interactions, HTTP requests, responses, and validation. It provides examples of building an API for user groups, events, and venues using Laravel resources, requests, and testing methods like assertStatus and assertJson. The goal is to gradually build out the API with tests to ensure functionality without using an API client.
Beginners overview of automated testing with Rspecjeffrey1ross
The document provides an overview of automated testing for beginning developers, covering testing basics like unit tests and code coverage, popular Ruby testing tools and techniques like RSpec and Capybara, the benefits of automated testing like improved code quality and efficiency, and strategies for testing models, controllers, and views. It also discusses testing patterns and principles like the inverted testing pyramid, page object pattern, and single responsibility principle.
Jumpstarting Testing In Your Organization with Selenium, Cucumber, & WebdriverIOJosh Cypher
With modern software development moving at a rapid pace, automation engineers may find it difficult to keep up with frequent changes. Incorporating parts of the testing process into everyone's workflow, this creates the potential for automated testing to mirror software delivery.
Description: With modern software development moving at a rapid pace, automation engineers may find it difficult to keep up with frequent changes. But if parts of the testing process are incorporated into everyone's workflow, this creates the potential for automated testing to mirror software delivery. My goal is to make software testing more accessible to entire product and engineering teams by providing familiar tools that allow individuals to easily contribute to the automation process. For this talk, I will explore how we can meet developers halfway by using the javascript-based testing framework WebdriverIO, demonstrate how product managers can create living documentation and test cases using Cucumber, and talk about sharing page objects and testing libraries across multiple services using NPM.
Code Examples:
https://github.com/dcypherthis/gtr-test-cucumber
https://github.com/dcypherthis/gtr-test-mocha-bdd
https://github.com/dcypherthis/gtr-test-xray
This document discusses best practices for unit testing. It addresses common issues like tests that run slowly, are hard to understand, or test the same thing repeatedly. It provides solutions such as grouping test files by criteria and naming conventions to make tests self-documenting. It advises against over-complex mocks and duplicated logic in tests. Tests should be written clearly so others can easily understand what is being tested when debugging or refactoring code. The key messages are to keep tests focused on specific units, refactor tests that become confusing, and make tests self-explanatory through naming and comments.
The document discusses integration testing for web applications in Python. It describes integration tests as high-level tests that simulate browser interactions and span multiple components. It then discusses different tools for integration testing like Selenium, Splinter and a custom library called easy_integration that aims to simplify the process. The key benefits of easy_integration are that it runs on top of Splinter and Selenium without requiring manual browser object management and has a simple API for common test actions.
Force.com lets developers rapidly create and deploy trusted cloud apps that are rock solid, secure, and scalable. In part I of the webinar series, you learn how to build your 1st app using the foundational features of Force.com.
Key Takeaways
- Get a platform overview
- Learn about the object model basics
- Learn about the business logic implementation with code
- Customize the user interface
Lightning Components 101: An Apex Developer's GuideAdam Olshansky
Don't hesitate to get into front end development on Salesforce! Check out the principles of backend code you already know as well as some of the new tricks to developing front end code on the Salesforce platform using the new Lightning Web Components model!
As presented at Force Academy LA 2018, walk through the steps of how to write a Trigger, expand to a robust Trigger handler, and finally implement a framework to make Apex do the routing for you!
The document discusses using dynamic Apex and the Tooling API to write highly genericized code in Salesforce. It begins with an overview of writing generic code in Apex and the benefits of a dynamic approach over static code. Examples are provided of using dynamic Apex for metadata, data, controllers, and SOQL. The Tooling API is then introduced as a way to build tools by gathering metadata about orgs and code. Potential uses of the Tooling API are outlined, such as symbol table visualization, testing tools, and customizing managed packages. The summary concludes by encouraging attendees to apply what they've learned to build their own tools.
Salesforce Connect allows administrators to integrate Salesforce with external data sources without writing code. It uses the OData protocol to provide real-time, bi-directional access to external databases on any device. Administrators can set up external data sources by defining an authentication method and connection URL. This allows external data to be viewed and manipulated from within Salesforce just like native objects, including CRUD permissions. Considerations for using Salesforce Connect include its paid feature status, current limitations around approval processes and validation rules, and the benefits of reducing integration costs.
Programming Foundation Models with DSPy - Meetup SlidesZilliz
Prompting language models is hard, while programming language models is easy. In this talk, I will discuss the state-of-the-art framework DSPy for programming foundation models with its powerful optimizers and runtime constraint system.
Letter and Document Automation for Bonterra Impact Management (fka Social Sol...Jeffrey Haguewood
Sidekick Solutions uses Bonterra Impact Management (fka Social Solutions Apricot) and automation solutions to integrate data for business workflows.
We believe integration and automation are essential to user experience and the promise of efficient work through technology. Automation is the critical ingredient to realizing that full vision. We develop integration products and services for Bonterra Case Management software to support the deployment of automations for a variety of use cases.
This video focuses on automated letter generation for Bonterra Impact Management using Google Workspace or Microsoft 365.
Interested in deploying letter generation automations for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
GraphRAG for Life Science to increase LLM accuracyTomaz Bratanic
GraphRAG for life science domain, where you retriever information from biomedical knowledge graphs using LLMs to increase the accuracy and performance of generated answers
TrustArc Webinar - 2024 Global Privacy SurveyTrustArc
How does your privacy program stack up against your peers? What challenges are privacy teams tackling and prioritizing in 2024?
In the fifth annual Global Privacy Benchmarks Survey, we asked over 1,800 global privacy professionals and business executives to share their perspectives on the current state of privacy inside and outside of their organizations. This year’s report focused on emerging areas of importance for privacy and compliance professionals, including considerations and implications of Artificial Intelligence (AI) technologies, building brand trust, and different approaches for achieving higher privacy competence scores.
See how organizational priorities and strategic approaches to data security and privacy are evolving around the globe.
This webinar will review:
- The top 10 privacy insights from the fifth annual Global Privacy Benchmarks Survey
- The top challenges for privacy leaders, practitioners, and organizations in 2024
- Key themes to consider in developing and maintaining your privacy program
Have you ever been confused by the myriad of choices offered by AWS for hosting a website or an API?
Lambda, Elastic Beanstalk, Lightsail, Amplify, S3 (and more!) can each host websites + APIs. But which one should we choose?
Which one is cheapest? Which one is fastest? Which one will scale to meet our needs?
Join me in this session as we dive into each AWS hosting service to determine which one is best for your scenario and explain why!
Trusted Execution Environment for Decentralized Process MiningLucaBarbaro3
Presentation of the paper "Trusted Execution Environment for Decentralized Process Mining" given during the CAiSE 2024 Conference in Cyprus on June 7, 2024.
Building Production Ready Search Pipelines with Spark and MilvusZilliz
Spark is the widely used ETL tool for processing, indexing and ingesting data to serving stack for search. Milvus is the production-ready open-source vector database. In this talk we will show how to use Spark to process unstructured data to extract vector representations, and push the vectors to Milvus vector database for search serving.
Ocean lotus Threat actors project by John Sitima 2024 (1).pptxSitimaJohn
Ocean Lotus cyber threat actors represent a sophisticated, persistent, and politically motivated group that poses a significant risk to organizations and individuals in the Southeast Asian region. Their continuous evolution and adaptability underscore the need for robust cybersecurity measures and international cooperation to identify and mitigate the threats posed by such advanced persistent threat groups.
How to Interpret Trends in the Kalyan Rajdhani Mix Chart.pdfChart Kalyan
A Mix Chart displays historical data of numbers in a graphical or tabular form. The Kalyan Rajdhani Mix Chart specifically shows the results of a sequence of numbers over different periods.
Taking AI to the Next Level in Manufacturing.pdfssuserfac0301
Read Taking AI to the Next Level in Manufacturing to gain insights on AI adoption in the manufacturing industry, such as:
1. How quickly AI is being implemented in manufacturing.
2. Which barriers stand in the way of AI adoption.
3. How data quality and governance form the backbone of AI.
4. Organizational processes and structures that may inhibit effective AI adoption.
6. Ideas and approaches to help build your organization's AI strategy.
Best 20 SEO Techniques To Improve Website Visibility In SERPPixlogix Infotech
Boost your website's visibility with proven SEO techniques! Our latest blog dives into essential strategies to enhance your online presence, increase traffic, and rank higher on search engines. From keyword optimization to quality content creation, learn how to make your site stand out in the crowded digital landscape. Discover actionable tips and expert insights to elevate your SEO game.
Digital Marketing Trends in 2024 | Guide for Staying AheadWask
https://www.wask.co/ebooks/digital-marketing-trends-in-2024
Feeling lost in the digital marketing whirlwind of 2024? Technology is changing, consumer habits are evolving, and staying ahead of the curve feels like a never-ending pursuit. This e-book is your compass. Dive into actionable insights to handle the complexities of modern marketing. From hyper-personalization to the power of user-generated content, learn how to build long-term relationships with your audience and unlock the secrets to success in the ever-shifting digital landscape.
A Comprehensive Guide to DeFi Development Services in 2024Intelisync
DeFi represents a paradigm shift in the financial industry. Instead of relying on traditional, centralized institutions like banks, DeFi leverages blockchain technology to create a decentralized network of financial services. This means that financial transactions can occur directly between parties, without intermediaries, using smart contracts on platforms like Ethereum.
In 2024, we are witnessing an explosion of new DeFi projects and protocols, each pushing the boundaries of what’s possible in finance.
In summary, DeFi in 2024 is not just a trend; it’s a revolution that democratizes finance, enhances security and transparency, and fosters continuous innovation. As we proceed through this presentation, we'll explore the various components and services of DeFi in detail, shedding light on how they are transforming the financial landscape.
At Intelisync, we specialize in providing comprehensive DeFi development services tailored to meet the unique needs of our clients. From smart contract development to dApp creation and security audits, we ensure that your DeFi project is built with innovation, security, and scalability in mind. Trust Intelisync to guide you through the intricate landscape of decentralized finance and unlock the full potential of blockchain technology.
Ready to take your DeFi project to the next level? Partner with Intelisync for expert DeFi development services today!
Introduction of Cybersecurity with OSS at Code Europe 2024Hiroshi SHIBATA
I develop the Ruby programming language, RubyGems, and Bundler, which are package managers for Ruby. Today, I will introduce how to enhance the security of your application using open-source software (OSS) examples from Ruby and RubyGems.
The first topic is CVE (Common Vulnerabilities and Exposures). I have published CVEs many times. But what exactly is a CVE? I'll provide a basic understanding of CVEs and explain how to detect and handle vulnerabilities in OSS.
Next, let's discuss package managers. Package managers play a critical role in the OSS ecosystem. I'll explain how to manage library dependencies in your application.
I'll share insights into how the Ruby and RubyGems core team works to keep our ecosystem safe. By the end of this talk, you'll have a better understanding of how to safeguard your code.
Introduction of Cybersecurity with OSS at Code Europe 2024
Apex Testing Deep Dive
1. #SalesforceApexHourswww.ApexHours.com
Salesforce Apex Hours
Farmington Hill Salesforce Developer Group
Apex Testing Deep Dive
#SalesforceApexHours
#SalesforceApexHours
Speaker
Date
Venue/Link
Adam Olshansky
Saturday, JUN 6, 2020 10:00 AM EST ( 8:30 PM IST )
Online
www.apexhours.com
2. #SalesforceApexHourswww.ApexHours.com
Who I am
Amit Chaudhary (Salesforce MVP)
• Active on Salesforce Developer Community
• Blogging at http://amitsalesforce.blogspot.in/
• Co-Organizer of – FarmingtonHillsSFDCDug
• Founder of www.ApexHours.com
• Follow us @Amit_SFDC or @ApexHours
19. #SalesforceApexHourswww.ApexHours.com
How to Create Test Data
• Manually create it for each test
• Pro: Variables in context
• Con: Lots of duplicate code
• Load data via CSV Static Resource
• Pro: Don’t need to make code updates for record creation
• Con: Might be harder to track changes to static resources
• Test Setup
• Pro: Reduce repetitive code
• Con: Variables out of context
• Test Factory
• Pro: Single location to update schema in code
• Con: Variables out of context
21. #SalesforceApexHourswww.ApexHours.com
Asserts in Tests
• Confirm that code works as you expect it to
• System.assert(condition, msg)
• System.assertEquals(expected, actual, msg)
• System.assertNotEquals(expected, actual, msg)
• What controls whether or not your tests pass
30. #SalesforceApexHourswww.ApexHours.com
System.runAs()
• Code needs to be tested as different users
• Create/find a user and test on their behalf
• Only applies to sharing, not FLS
• Useful for avoiding Mixed DML errors
• Useful for testing a specific version of managed package
AccountTrigger
Enable System.asserts in TestFactoryTests
TestVisible in OpportunityHandler
Tests in OpportunityTests
Show Code Coverage
TestSuite Example
Create .vscode directory
Run on side menu. Create launch.json file with config for Apex Replay Debugger
Toggle Checkpoint
Update Checkpoints in Org
Turn On Apex Debug Log for Replay Debugger
Run Code
Get Apex Debug Log (can also get log from user, can download from .sfdx/tools/debug/logs)
Right Click in log and select Launch Apex Replay Debugger with Current File
Advance through code