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.
Your One-Stop Shop for Python Success: Top 10 US Python Development Providersakankshawande
Simplify your search for a reliable Python development partner! This list presents the top 10 trusted US providers offering comprehensive Python development services, ensuring your project's success from conception to completion.
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.
5th LF Energy Power Grid Model Meet-up SlidesDanBrown980551
5th Power Grid Model Meet-up
It is with great pleasure that we extend to you an invitation to the 5th Power Grid Model Meet-up, scheduled for 6th June 2024. This event will adopt a hybrid format, allowing participants to join us either through an online Mircosoft Teams session or in person at TU/e located at Den Dolech 2, Eindhoven, Netherlands. The meet-up will be hosted by Eindhoven University of Technology (TU/e), a research university specializing in engineering science & technology.
Power Grid Model
The global energy transition is placing new and unprecedented demands on Distribution System Operators (DSOs). Alongside upgrades to grid capacity, processes such as digitization, capacity optimization, and congestion management are becoming vital for delivering reliable services.
Power Grid Model is an open source project from Linux Foundation Energy and provides a calculation engine that is increasingly essential for DSOs. It offers a standards-based foundation enabling real-time power systems analysis, simulations of electrical power grids, and sophisticated what-if analysis. In addition, it enables in-depth studies and analysis of the electrical power grid’s behavior and performance. This comprehensive model incorporates essential factors such as power generation capacity, electrical losses, voltage levels, power flows, and system stability.
Power Grid Model is currently being applied in a wide variety of use cases, including grid planning, expansion, reliability, and congestion studies. It can also help in analyzing the impact of renewable energy integration, assessing the effects of disturbances or faults, and developing strategies for grid control and optimization.
What to expect
For the upcoming meetup we are organizing, we have an exciting lineup of activities planned:
-Insightful presentations covering two practical applications of the Power Grid Model.
-An update on the latest advancements in Power Grid -Model technology during the first and second quarters of 2024.
-An interactive brainstorming session to discuss and propose new feature requests.
-An opportunity to connect with fellow Power Grid Model enthusiasts and users.
In the rapidly evolving landscape of technologies, XML continues to play a vital role in structuring, storing, and transporting data across diverse systems. The recent advancements in artificial intelligence (AI) present new methodologies for enhancing XML development workflows, introducing efficiency, automation, and intelligent capabilities. This presentation will outline the scope and perspective of utilizing AI in XML development. The potential benefits and the possible pitfalls will be highlighted, providing a balanced view of the subject.
We will explore the capabilities of AI in understanding XML markup languages and autonomously creating structured XML content. Additionally, we will examine the capacity of AI to enrich plain text with appropriate XML markup. Practical examples and methodological guidelines will be provided to elucidate how AI can be effectively prompted to interpret and generate accurate XML markup.
Further emphasis will be placed on the role of AI in developing XSLT, or schemas such as XSD and Schematron. We will address the techniques and strategies adopted to create prompts for generating code, explaining code, or refactoring the code, and the results achieved.
The discussion will extend to how AI can be used to transform XML content. In particular, the focus will be on the use of AI XPath extension functions in XSLT, Schematron, Schematron Quick Fixes, or for XML content refactoring.
The presentation aims to deliver a comprehensive overview of AI usage in XML development, providing attendees with the necessary knowledge to make informed decisions. Whether you’re at the early stages of adopting AI or considering integrating it in advanced XML development, this presentation will cover all levels of expertise.
By highlighting the potential advantages and challenges of integrating AI with XML development tools and languages, the presentation seeks to inspire thoughtful conversation around the future of XML development. We’ll not only delve into the technical aspects of AI-powered XML development but also discuss practical implications and possible future directions.
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.
HCL Notes and Domino License Cost Reduction in the World of DLAUpanagenda
Webinar Recording: https://www.panagenda.com/webinars/hcl-notes-and-domino-license-cost-reduction-in-the-world-of-dlau/
The introduction of DLAU and the CCB & CCX licensing model caused quite a stir in the HCL community. As a Notes and Domino customer, you may have faced challenges with unexpected user counts and license costs. You probably have questions on how this new licensing approach works and how to benefit from it. Most importantly, you likely have budget constraints and want to save money where possible. Don’t worry, we can help with all of this!
We’ll show you how to fix common misconfigurations that cause higher-than-expected user counts, and how to identify accounts which you can deactivate to save money. There are also frequent patterns that can cause unnecessary cost, like using a person document instead of a mail-in for shared mailboxes. We’ll provide examples and solutions for those as well. And naturally we’ll explain the new licensing model.
Join HCL Ambassador Marc Thomas in this webinar with a special guest appearance from Franz Walder. It will give you the tools and know-how to stay on top of what is going on with Domino licensing. You will be able lower your cost through an optimized configuration and keep it low going forward.
These topics will be covered
- Reducing license cost by finding and fixing misconfigurations and superfluous accounts
- How do CCB and CCX licenses really work?
- Understanding the DLAU tool and how to best utilize it
- Tips for common problem areas, like team mailboxes, functional/test users, etc
- Practical examples and best practices to implement right away
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.
Salesforce Integration for Bonterra Impact Management (fka Social Solutions A...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 integration of Salesforce with Bonterra Impact Management.
Interested in deploying an integration with Salesforce for Bonterra Impact Management? Contact us at sales@sidekicksolutionsllc.com to discuss next steps.
Main news related to the CCS TSI 2023 (2023/1695)Jakub Marek
An English 🇬🇧 translation of a presentation to the speech I gave about the main changes brought by CCS TSI 2023 at the biggest Czech conference on Communications and signalling systems on Railways, which was held in Clarion Hotel Olomouc from 7th to 9th November 2023 (konferenceszt.cz). Attended by around 500 participants and 200 on-line followers.
The original Czech 🇨🇿 version of the presentation can be found here: https://www.slideshare.net/slideshow/hlavni-novinky-souvisejici-s-ccs-tsi-2023-2023-1695/269688092 .
The videorecording (in Czech) from the presentation is available here: https://youtu.be/WzjJWm4IyPk?si=SImb06tuXGb30BEH .
Threats to mobile devices are more prevalent and increasing in scope and complexity. Users of mobile devices desire to take full advantage of the features
available on those devices, but many of the features provide convenience and capability but sacrifice security. This best practices guide outlines steps the users can take to better protect personal devices and information.
Unlock the Future of Search with MongoDB Atlas_ Vector Search Unleashed.pdfMalak Abu Hammad
Discover how MongoDB Atlas and vector search technology can revolutionize your application's search capabilities. This comprehensive presentation covers:
* What is Vector Search?
* Importance and benefits of vector search
* Practical use cases across various industries
* Step-by-step implementation guide
* Live demos with code snippets
* Enhancing LLM capabilities with vector search
* Best practices and optimization strategies
Perfect for developers, AI enthusiasts, and tech leaders. Learn how to leverage MongoDB Atlas to deliver highly relevant, context-aware search results, transforming your data retrieval process. Stay ahead in tech innovation and maximize the potential of your applications.
#MongoDB #VectorSearch #AI #SemanticSearch #TechInnovation #DataScience #LLM #MachineLearning #SearchTechnology
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.
Monitoring and Managing Anomaly Detection on OpenShift.pdfTosin Akinosho
Monitoring and Managing Anomaly Detection on OpenShift
Overview
Dive into the world of anomaly detection on edge devices with our comprehensive hands-on tutorial. This SlideShare presentation will guide you through the entire process, from data collection and model training to edge deployment and real-time monitoring. Perfect for those looking to implement robust anomaly detection systems on resource-constrained IoT/edge devices.
Key Topics Covered
1. Introduction to Anomaly Detection
- Understand the fundamentals of anomaly detection and its importance in identifying unusual behavior or failures in systems.
2. Understanding Edge (IoT)
- Learn about edge computing and IoT, and how they enable real-time data processing and decision-making at the source.
3. What is ArgoCD?
- Discover ArgoCD, a declarative, GitOps continuous delivery tool for Kubernetes, and its role in deploying applications on edge devices.
4. Deployment Using ArgoCD for Edge Devices
- Step-by-step guide on deploying anomaly detection models on edge devices using ArgoCD.
5. Introduction to Apache Kafka and S3
- Explore Apache Kafka for real-time data streaming and Amazon S3 for scalable storage solutions.
6. Viewing Kafka Messages in the Data Lake
- Learn how to view and analyze Kafka messages stored in a data lake for better insights.
7. What is Prometheus?
- Get to know Prometheus, an open-source monitoring and alerting toolkit, and its application in monitoring edge devices.
8. Monitoring Application Metrics with Prometheus
- Detailed instructions on setting up Prometheus to monitor the performance and health of your anomaly detection system.
9. What is Camel K?
- Introduction to Camel K, a lightweight integration framework built on Apache Camel, designed for Kubernetes.
10. Configuring Camel K Integrations for Data Pipelines
- Learn how to configure Camel K for seamless data pipeline integrations in your anomaly detection workflow.
11. What is a Jupyter Notebook?
- Overview of Jupyter Notebooks, an open-source web application for creating and sharing documents with live code, equations, visualizations, and narrative text.
12. Jupyter Notebooks with Code Examples
- Hands-on examples and code snippets in Jupyter Notebooks to help you implement and test anomaly detection models.
Monitoring and Managing Anomaly Detection on OpenShift.pdf
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