Menu

quality assurance

Explore our insightful blog posts that delve deeper into the latest industry trends, best practices, and success stories. Gain valuable knowledge and stay informed about the ever-evolving landscape of digital transformation.

Suggested categories

Understanding Software Testing And Its Types

Reliability is paramount for the tech industry and to achieve that, testing and quality assurance (QA) stand as pillars of success. These disciplines aren’t just about finding bugs; they’re about crafting experiences, mitigating risks, and ensuring that every software solution meets and exceeds expectations. Let’s dive into the intricacies of testing in software engineering, exploring its various levels, types, techniques, and automation practices, all aimed at keeping users engaged and satisfied.Understanding Levels and Types of Testing:Manual Testing:Testing techniques like black box, white box, and grey box testing provide different perspectives for a thorough evaluation, whether focusing solely on functionality (black box), delving into internal logic (white box), or combining both (grey box).Black Box TestingImagine you’re a user navigating through a new software application without any knowledge of its internal workings. This is precisely what black box testing entails. Testers approach the software purely from an end-user perspective, focusing on exploring its functionalities, inputs, outputs, and expected behaviors without accessing or analyzing the underlying code.Black box testing allows testers to uncover bugs, errors, and inconsistencies that may impact user experience, functionality, or usability. By simulating real-world usage scenarios, testers can identify issues that users might encounter and provide valuable feedback to developers for improvements.White Box TestingOn the other hand, white box testing involves diving deep into the inner workings of the software, much like an artist scrutinizing the intricate details and structure of a painting. Testers have access to the codebase and analyze the software’s internal logic, algorithms, data structures, and code paths.White box testing focuses on verifying the correctness of the software’s code, ensuring that it follows design specifications, standards, and best practices. Testers create test cases based on code coverage, decision paths, and boundary conditions to validate the software’s integrity and functionality at a granular level.This approach allows testers to detect programming errors, logic flaws, and performance bottlenecks that may not be apparent from an external perspective. It’s like examining the foundation and framework of a building to ensure stability and reliability.Grey Box TestingGrey box testing strikes a balance between black box and white box testing, offering a nuanced perspective similar to an artist stepping back to view their work from different angles. Testers have partial knowledge of the software’s internal structure and functionalities, combining elements of user experience and code analysis.In grey box testing, testers leverage their understanding of the software’s architecture, design patterns, and integration points to design effective test cases. They focus on areas where the user interface interacts with backend systems, ensuring seamless integration and functionality across different components.This approach allows testers to validate system-level interactions, data flow, and integration scenarios, enhancing overall software quality and reliability. It’s like seeing a painting from various viewpoints to appreciate its depth and coherence.Functional TestingFunctional testing focuses on verifying that the software performs its intended functions accurately and meets the specified requirements. It involves testing various functionalities of the software to ensure they work as expected from an end-user perspective. Imagine it as putting the software through a series of tasks to check if it accomplishes what it’s supposed to do.For example, in an e-commerce application, functional testing would involve testing features like user registration, product search, adding items to the cart, checkout process, and order tracking. Testers simulate user interactions to validate that each function works smoothly and produces the correct results.Functional testing ensures that the software meets user expectations in terms of functionality, features, and usability. It helps identify bugs, errors, and deviations from requirements, enabling developers to make necessary fixes and improvements.Unit Testing: This level focuses on testing individual units or components of the software, akin to checking each brick’s strength in a building.Integration Testing: Like assembling a puzzle, this level ensures that different modules integrate seamlessly, forming a cohesive whole.System Testing: Here, the entire software system undergoes evaluation to verify its functionality across various scenarios, resembling a comprehensive dress rehearsal.Non-Functional TestingOn the other hand, non-functional testing focuses on aspects beyond the core functionality of the software. It evaluates the software’s performance, reliability, security, usability, and other non-functional attributes. Non-functional testing is like assessing the overall quality and experience of using the software, rather than just its specific functions.Here are some key types of non-functional testing:Performance Testing: This is a type of testing that evaluates how a software application performs under various conditions and scenarios. It assesses the responsiveness, scalability, reliability, and speed of the software, particularly when subjected to different levels of workload or stress. It helps identify performance bottlenecks, optimize resource utilization, improve response times, and enhance overall user experience by ensuring that the software meets performance requirements and user expectations.Usability Testing: It focuses on evaluating the user interface (UI) and user experience (UX) of a software application to ensure it is intuitive, easy to use, and meets user expectations. It involves gathering feedback from real users through tasks, scenarios, and usability surveys to assess the software’s usability aspects.Compatibility Testing: It ensures that a software application functions correctly and consistently across different devices, platforms, browsers, operating systems, and environments. It verifies that the software is compatible with a wide range of configurations and configurations commonly used by end-users.Automation Testing:Automation in testing, facilitated by tools like Selenium, JUnit, and TestNG, enhances efficiency, reduces manual errors, and supports continuous integration practices, ensuring rapid feedback cycles and reliable software releases.SeleniumSelenium is a widely used open-source automation testing tool that allows testers and developers to automate web browser interactions, perform functional testing, and verify web applications’ behavior across different browsers and platforms.JUnit5JUnit 5 represents the latest iteration of the JUnit testing framework, offering a contemporary platform for conducting developer-oriented testing within the Java Virtual Machine (JVM). It emphasizes compatibility with Java versions 8 and beyond while also supporting a wide range of testing methodologies.TestNGTestNG is a testing framework that draws inspiration from JUnit and NUnit while introducing innovative functionalities that enhance its power and user-friendliness.Testing in Agile and DevOps Environments:In agile environments, testing is integrated into development cycles, promoting collaboration, iterative testing, and rapid feedback to accommodate changing requirements seamlessly.DevOps testing emphasizes continuous testing and integration throughout the development and deployment pipeline, ensuring that software changes are thoroughly tested before reaching production, thereby enhancing reliability and stability.Quality Metrics:Quality metrics are tools used to measure and evaluate the effectiveness of testing processes and the overall quality of software products. They offer valuable insights into various aspects of testing and help teams make informed decisions to improve product quality continuously.Defect Density:Defect density is a metric that quantifies the number of defects or issues found in the software per unit of code, typically measured as defects per line of code or defects per function point. A higher defect density may indicate areas of the software that require more attention or improvement, highlighting potential areas for bug fixes and code optimization.Test Coverage:Test coverage measures the extent to which testing covers different aspects of the software, including functionalities, requirements, and code paths. It helps assess the thoroughness of testing efforts by determining the percentage of code or functionalities tested compared to the total codebase or requirements. Higher test coverage indicates more comprehensive testing, reducing the risk of undetected issues in untested areas of the software.Test Reports:Test reports provide detailed summaries of test results, including information about past tests, failed tests, defects discovered, and overall testing progress. These reports offer visibility into the status of testing activities, highlighting areas that require attention and improvement. Test reports also aid in decision-making by providing data-driven insights into the software’s readiness for release and identifying areas for further testing or refinement.Crafting User-Centric Experiences:Ultimately, testing in software engineering is about crafting user-centric experiences that meet and exceed expectations. By embracing diverse testing methodologies, automation practices, and quality assurance frameworks, organizations can unlock excellence, ensuring software solutions that captivate users and foster long-term satisfaction and loyalty.Testing and quality assurance are indispensable components of software engineering that ensure product quality, reliability, and customer satisfaction. By leveraging a diverse array of testing levels, types, techniques, automation tools, and quality metrics, organizations can deliver software solutions that stand out in the market, driving innovation and delighting users with exceptional experiences. Let’s continue on this journey of excellence, where every line of code is meticulously tested, and every software release is a testament to craftsmanship and user-centric design with us!

Learn More >

Chaos Testing Explained

An overviewChaos Testing is an invaluable part of Performance Engineering. It comprises 5 principles that help us test possible system failures that may cause unplanned downtime for the consumers.Teams across organizations can utilize chaos testing by creating systems of monitoring and running it in a production environment to see real-life simulations of how their software applications or service responds to different stress levels.An overview of its various principles, the derived benefits, and the various tools are shown below.

Learn More >

Performance Testing Trends: Future of Software Optimization

Performance testing is an integral part of the software development lifecycle as it helps determine the scalability, stability, speed, and responsiveness of an application as compared to the workload given. It is not a standalone process and should be run throughout the software development process.It serves the purpose of assessing various aspects of an application’s performance, such as application output, processing speed, data transfer velocity, network bandwidth usage, maximum concurrent users, memory utilization, workload efficiency, and command response times. By evaluating these metrics, performance testers can gain valuable insights into the application’s capabilities and identify any areas that require improvementUsing AI to automate testing:Performance testing encompasses various stages, each posing unique challenges throughout the testing lifecycle. These challenges include test preparation, execution, identifying performance bottlenecks, pinpointing root causes, and implementing effective solutions. AI can help reduce or even eliminate these differences. AI-powered systems can handle the mountains of data collected during performance testing and be able to produce efficient and accurate analyses. AI can also identify the sources of performance slowdowns in complex systems, which can otherwise be tedious to pinpoint. With AI-driven automation, performance testers can streamline the testing process, ultimately saving time and resources while ensuring reliable results.Open Architecture:Performance testing, which evaluates how well a system performs, is undergoing a significant shift away from relying solely on browser-based evaluations. Instead, internet protocols like TCP/IP are being adopted for comprehensive performance monitoring. This approach emphasizes the need for system components to work together harmoniously while assessing their performance individually. The integration of cloud-based environments has become crucial, as cloud computing is an integral part of modern technology infrastructure. Cloud-based environments provide a flexible and reliable platform that enables seamless integration and coordination of various components, ultimately leading to enhanced system performance. It is crucial to prioritize comprehensive performance testing, which involves evaluating individual component performance, managing loads, monitoring in real-time, and debugging, to ensure optimal system performance.Self Service:When adopting the aforementioned trends, it’s essential to consider practical implementation tips for successful outcomes. For instance, performance engineers can use AI-powered tools to analyze performance data more effectively, leading to more accurate and actionable insights. Integrating cloud-based solutions can provide the flexibility and scalability required for modern performance testing demands. As stakeholders implement these trends, the collaboration between development, testing, and IT operations teams becomes crucial for successful integration and improved application performance.SaaS-based Tools:Testers can now easily set up and execute tests at cloud scale within minutes, thanks to the convergence of self-service, cloud-based testing, SaaS, and open architecture. Unlike older desktop-based tools that demand extensive setup, the emerging tools simplify the process with just a few clicks. Furthermore, these modern technologies offer seamless interoperability, significantly enhancing performance capabilities.Changing Requirements:In classic app testing, testers had to make educated guesses about the software’s use and create requirements and service-level agreements accordingly. However, in DevOps-oriented environments, performance requirements are seen as dynamic and evolving. Traditional requirements are now driven by complex use cases, accommodating different user experiences across various devices and locations. Performance engineering plays a critical role in continuously monitoring systems and proactively identifying and resolving issues before they can negatively impact customer retention or sales.Sentiment analysis:Monitoring production provides insight into server response times but does not capture the true customer experience. Synthetic transactions, on the other hand, simulate real user actions in production continuously. They can range from basic interactions like logging into an e-commerce site and adding products to a cart, to more complex transactions that track performance end to end without actually completing real orders or charging credit cards. Tracking the actual user experience is crucial for identifying bottlenecks, delays, and errors in real-time, as some issues may go unreported by users. Sentiment analysis is a powerful technology that evaluates customer responses based on emotions, providing valuable insights from customers’ reactions expressed in plain text and assigning numerical sentiment scores.Chaos Testing:Chaos testing is a disciplined methodology that proactively simulates and identifies failures in a system to prevent unplanned downtime and ensure a positive user experience. By understanding how the application responds to failures in various parts of the architecture, chaos testing helps uncover uncertainties in the production environment. The main objective is to assess the system’s behavior in the event of failures and identify potential issues. For instance, if one web service experiences downtime, chaos testing ensures that the entire infrastructure does not collapse. This approach helps identify system weaknesses and addresses them before reaching the production stage.Conclusion:As software development continues to evolve, performance testing must keep pace with emerging trends and technologies. By leveraging AI-driven automation, open architecture with cloud integration, and practical implementation tips, stakeholders can optimize their performance testing processes to deliver high-performing and responsive software applications. Real-world examples and a focus on key performance metrics ensure that these trends are not only understood but effectively implemented to achieve the desired outcomes. Embracing these trends empowers software development teams to elevate the user experience, enhance customer satisfaction, and drive business success.

Learn More >

Fixing FCM Push Notifications: Solutions for Common Issues

Firebase Cloud Messaging (FCM) is a cross-platform messaging solution that lets you reliably deliver messages at no cost.Using FCM:1.You can notify a client app that new email or other data is available to sync.2.You can send notification messages to drive user re-engagement and retention.For use cases such as instant messaging, a message can transfer a payload of up to 4KB to a client app.Detailed information on Firebase Cloud Messaging can be found in here: https://firebase.google.com/docs/cloud-messaging/But there are some situations where we need to fix the issues related to FCM push notifications such as:1.Notification is not working in the Oreo.2.Notification is not working as a background service in One plus 3/3T.In situation one, Oreo, the latest version of Android, supports some methods and classes which are not used by the legacy code present in the application.The below mentioned line of code snippet will help you fix it. if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) { int importance = NotificationManager.IMPORTANCE_HIGH; NotificationChannel mChannel = new NotificationChannel(NOTIFICATION_CHANNEL_ID, title, importance); mChannel.setDescription(notification); mChannel.enableLights(true); mChannel.setLightColor(ContextCompat.getColor(getApplicationContext(),R.color .colorPrimary)); notificationManager.createNotificationChannel(mChannel); }view rawfcm hosted with ❤ by GitHubIn situation two, where the notification is not working as a background service in One plus 3/3T, turn your battery optimisation off and it’s done. You will now receive the push notification.

Learn More >

Importance of Test Automation: Optimizing Coverage

A survey conducted by TEST magazine in association with Software Testing News revealed that 24% of participants witnessed a return on their test automation investment immediately while another 24% within the first 6 months. The report also found that 66% of the respondents were either on 25:75 or at 50:50 (manual: automated testing). The importance of test automation has become well-known in the software industry. It is now considered to be one of the key factors in the success of any project, given the increasing adoption of agile software development practices and rapid product releasesTechnical definition of test automation is “A method in software testing that makes use of special software tools to control the execution of tests and then compares actual test results with predicted or expected results”.In simple terms, it is a technique that efficiently uses tools and programs to carry out repetitive tasks, significantly reducing manual efforts in verification process.Automation plays an important role, especially, when an application grows in time. In such cases, manual testing turns out to be an expensive approach and makes it challenging to efficiently manage time, reliability and accuracy. So, let’s look at some of the key reasons why automation is considered to be critical for testing software.#1 Saves time and moneyManually running tests repetitively is time consuming and costly, automation allows you to run these tests way faster, reducing time and manual effort. Automation can handle a wide variety of repetitive tasks such as notifications and email workflow. While not every aspect of application can be automated, you can always identify and automate routine tasks in every release cycle. Automation not only eliminates the need to hire new resources to do the same task but also gives test engineers time to focus on critical and strategic aspects of an application. And as Benjamin Franklin said, “Time is Money”, automation helps optimize time and resource utilization, in turn saving cost of testing.#2 Optimizes test coverageQuality of application enhances significantly when we consider all the possible test cases. Test automation helps easily execute thousands of different complex test cases during every run, providing coverage and scope that is impossible with manual testing. It can be considered as one of the measurements of test quality that indicates the amount of code being tested.#3 Improves accuracyEven the most scrupulous testers tend to make mistake during monotonous manual testing. Software testing involves recording observations of multiple click and play scenarios dealing with various usage and input combinations and comparing results to expected outcome. In case the development environment changes frequently, likelihood of human error increases, compromising testing accuracy. Whereas, an automated workflow system eliminates stress and fatigue from repetitive tests and delivers accurate result of test execution with details of the failed scenarios clearly specified.#4 Identifies regression bugsThis has to be one of the key reasons why organizations should adopt automation for testing software. Creating an automated test, for every new bug caught, guarantees that the same bug will never reappear undetected. By having regression tests automated, we can test the functionality every time code is changed, saving time, money and resources as discussed earlier. While it may not be possible to automate all the aspects of an application, some of the key areas you can focus on include — frequently changing code base, most used features and easy addition to automated test suite. Automating these aspects not only enhance test processes but also significantly reduce regression issues.#5 Improves team moraleWe have experienced it firsthand that both the Dev and QA teams rely on test automation as a first step to certify the application after every check-in of dev code. Automated testing has the potential to detect immediate bugs after deployment that can be fixed quickly. While it is not a tangible benefit, since automated testing improves depth and scope, it helps build trust amongst Dev and QA teams, boosting their morale and level of motivation.These are some of the many factors why automation plays a vital role in a project as per my experience working as an automation engineer, which made me believe that it is a necessity rather than fad. If you know of other factor/s that can strengthen the need for automation, please share your thoughts with us. And, stay tuned for future posts where we will talk about how to choose the right tool/framework and the stakeholders who will be impacted due to automation.

Learn More >

Optimizing Test Automation

In the last few years, there has been a shift in the software industry with regard to testing from manual to automation. Increased levels of automation in QA is one of the key trends highlighted in the World Quality Report. Many organizations are investing a huge amount of money to help testers move from manual to test automation, while others are replacing manual testers with automation engineers. And on the far end of the spectrum, there are players who have decided not to have a testing team at all.As organizations continue to shift gears to implement test automation, the industry is also witnessing a new trend. Many companies are gunning to achieve 100% automation of tests within unrealistic deadlines. This clearly indicates a shift in the focus from quality to the volume (quantity) of tests.There is no doubt that testing teams in organizations are under immense pressure to meet increasing demands but the core aim is to ensure superior product quality and user experience while ensuring a faster turnaround. And, in order to achieve that we need to optimize testing by integrating automation for the right amount of test cases.Here are top five actions items or best practices that can help you get that balance right.#1 Have the right kind of tests at the right place I am a very big advocate of the test pyramid since the day I learned about it. It requires the team to identify what tests go under which segment of the pyramid. When we try to cover every scenario/test via user interface (UI) automation, this not only increases the maintenance cost but also time to execute tests. When the test pyramid model is not used, then there is a risk of running into duplication of tests. From the unit testing to integration to UI automation, it provides a comprehensive testing base. This approach helps to maximize the value for your automation. It increases coverage, lowers cost and accelerates testing, making it an imperative approach in order to succeed in an agile development environment.#2 Do not downplay automation effortOne of the major challenges facing automation engineers is unrealistic deadlines set by managers. This often leads to automation engineers writing low-value scripts at a warp speed. And, probably writing more codes than developers at times as they need to test multiple scenarios to validate simple code change. The flip side to this is that they may meet deadlines but not quality parameters per se. Automation shouldn’t be underplayed. Managers need to ideally calibrate with their automation engineers to get a perspective on what should be automated and accordingly set a realistic timeline. This will not only help ensure these tests deliver quality, what they are intended to do but also speed things up in the right way.#3 Don’t conform to the traditional way of integrating automation, innovate rather Most of the times, when someone talks about automation, the focus shifts to user interface (UI) automation. UI automation is only one area of automation, based on project need, we should identify other areas as well where tests can be automated. For example, we have had automated tests that would monitor logs in servers and API in production and create an alert if a certain exception occurred. You could choose to automate SMS/Email testing or even validate responsive designs or data. While these may not fit into conventional categories such as UI or API or unit, but, why not have them running if they can add value.#4 You need not automate everything and that’s okMost automation goals are vague in nature such as aiming to achieve ‘100% automation of the tests’. This would force automation engineers to automate for the sake of automating, resulting in a number of flaky tests. Rather, the goal should be to implement effective automated tests with a tighter feedback loop. And here’s what Angie Jones, a Senior Automation Engineer at Twitter, has to say in the same context.#5 Managers who lead the automation team should be hands-on Managers who are not from automation background often fail to design effective automation strategy. Sometimes, unit tests are omitted with an excuse of delivery pressure and timelines. The ask for more of UI tests increases to account for the omission, this leads to automation engineers spending more time maintaining tests, leaving less time to write new ones. In that case, time saved in regression testing is spent maintaining automation tests, defeating the very purpose of having automation. Automation engineering is a discipline and therefore it is critical, for whoever is responsible for automation strategy, to have hands-on experience in order to design relevant and effective strategy.Whether or not automation is a silver bullet, I leave that judgment to my readers, please drop a comment to let me know what you think. Although, what I can most certainly conclude is that automation is a powerful weapon that can kill the beast but it requires skillful, strategic and effective handler.

Learn More >

Managing C# Dependencies: A Dive into Dependency Injection

Introduction:Have you ever struggled to manage C# dependencies in your projects? As your codebase grows, manually handling multiple dependencies can become daunting. Thankfully, there’s a solution that can streamline your code and improve its maintainability: dependency injection (DI). In this blog post, we’ll have a conversation where we explore a real-life scenario, discuss the challenges faced, and see how implementing dependency injection can provide an optimal solution.User: Hi there! I’ve heard much about dependency injection in C# lately, but I’m not sure how to implement it. Can you give me a beginner-friendly overview?C#: Absolutely! Dependency injection is a design pattern that helps manage the dependencies between components in your code. It allows you to write more modular and flexible code by reducing direct dependencies and promoting loose coupling.User: That sounds interesting! How can I start implementing dependency injection in my C# projects?C#: To implement dependency injection in C#, you can use a DI container or a DI framework. One popular choice is Microsoft.Extensions.DependencyInjection framework. It provides a lightweight and easy-to-use DI container. Let’s walk through an example to illustrate how it works.User: Great! I’m excited to see an example. Please show me how to use it.C#: Sure! First, you’ll need to install Microsoft.Extensions.DependencyInjection NuGet package. Once that’s done, you can create an instance of the ServiceCollection class, the DI container provided by the framework. Here’s a simple example:using Microsoft.Extensions.DependencyInjection;using System;// Define a class with a dependencypublic class Logger{ private readonly ILoggingService _loggingService; public Logger(ILoggingService loggingService) { _loggingService = loggingService; } public void Log(string message) { _loggingService.LogMessage(message); }}// Define an interface for the dependencypublic interface ILoggingService{ void LogMessage(string message);}// Implement the dependencypublic class ConsoleLogger : ILoggingService{ public void LogMessage(string message) { Console.WriteLine($"Logging message: {message}"); }}public class Program{ public static void Main() { // Configure the DI container var serviceProvider = new ServiceCollection() .AddTransient<ILoggingService, ConsoleLogger>() .BuildServiceProvider(); // Resolve the dependency var logger = serviceProvider.GetService<Logger>(); // Use the dependency logger.Log("Hello, world!"); }}In this example, we have a class called Logger that depends on an interface ILoggingService. The dependency is injected into Logger its constructor. By registering the dependency AddTransient in the DI container, we ensure that a new dependency instance is created each time it's requested.User: Ah, I see! So the DI container creates instances and injects them into the needed classes?C#: Exactly! The DI container manages the creation and injection of dependencies for you. It resolves the dependencies based on their registered types and provides them with the required classes.User: That’s convenient! Are there different ways to register dependencies in the DI container?C#: Absolutely! The ServiceCollection class provides various extension methods to register dependencies with other lifetimes. The most common ones are:AddTransient: A new dependency instance is created each time it’s requested.AddScoped: A new example of the dependency is created once per scope (e.g., per web request or logical operation).In conclusion, implementing dependency injection in our C# projects can greatly simplify managing dependencies and improve code maintainability. While Microsoft.Extensions.Dependency injection is a popular choice; we also have alternatives like Autofac, Ninject, Unity, and Simple Injector. Evaluate the features and characteristics of each framework to determine the best fit for your project. Happy coding!

Learn More >

Mastering Jasmine, a JavaScript Unit Testing Basics

“More than the act of testing, the act of designing tests is one of the best bug preventers known. The thinking that must be done to create a useful test can discover and eliminate bugs before they are coded — indeed, test-design thinking can discover and eliminate bugs at every stage in the creation of software, from conception to specification, to design, coding and the rest.” — Boris BeizerUnit Testing lets a developer validate a unit (class, function) of software. A developer may unknowingly make a change to an existing unit which could make the software go awry. Unit testing prevents such accidental cases. As soon as the developer writes some awry code for a unit, the test runner will let the person know which test case has failed.Coming to Javascript, various testing frameworks are available. Few popular ones are:MochaChaiJasmineIn the rest of the article, I would focus on few basics of the Jasmine framework.“Jasmine is a behavior-driven development framework for testing JavaScript code. It does not depend on any other JavaScript frameworks. It does not require a DOM (Document Object Model). And it has a clean, obvious syntax so that you can easily write tests.” -Jasmine Official DocumentationGetting started with Jasmine is fairly easy with below mentioned instructions:Installation:npm install –save-dev jasmineInitialise Project:jasmine initSeed Project with Examples:jasmine examplesRun Test Suite:jasmineA sample test case from the official doc looks like:describe(“A suite is just a function”, function() {var a;it(“and so is a spec”, function() {a = true;expect(a).toBe(true);});});I would dig more into this sample code.The test case typically comprises of:SuiteSpecMatcherCustom MatcherbeforeEachafterEachSuite:A test suite is a collection of test cases. The test suite does have a name (mentioned in the quotes). Below provided snippet is a typical jasmine test suite with 0 test cases.describe(“This is a jasmine test suite”, function() {});Spec:A test spec is a test specification for a unit. In jasmine, a spec starts with the keyword ‘it’ and has a spec message. Below provided snippet is a typical jasmine test spec not doing anything.it(“This is a jasmine test spec”, function() {});Matcher:Matcher is a check that lets you evaluate the output of a unit against a test result. Below provided snippet is a typical jasmine matcher.expect(func()).toBe(0);Let’s say, there is a function named func and it always returns a value 0. This function is a unit. If something goes awry with this function, the matcher will fail and hence, the unit test for the unit will fail.Custom Matchers, beforeEach, afterEach:Jasmine provides a number of inbuilt matchers. However, we can write our own custom matchers.beforeEach lets a developer define something before a spec is executed.An example would be to define a custom matcher in beforeEach and use the custom matcher in the spec. Below is a sample snippet:beforeEach(function () {this.addMatchers({toBeEven: function () {return (this.actual % 2) === 0;}});});it(‘should be even’, function () {expect(isEvenNumber()).toBeEven();});afterEach lets a developer define something after a spec is executed.How do I run tests:Jasmine provides a spec runner where you may run your tests. Another option would be to use a test runner like karma.As terminal is always fancier, a headless browser (like PhantomJS) should be preferred over Chrome.

Learn More >