Testing practices in Salesforce

A test script in Salesforce has two parts - Tests and Incidents, which can be best managed with Google Spreadsheets.  The tests define which process is being tested, the steps to be followed, expected result vs the actual results, the overall result and the incident number in case the test script fails. When a test script fails, an incident is created in the Incidents Tab. It includes the incident no., step no., the description of the actual result compared to the expected result, the cause for the failure and its potential fix. Once the fix has been made, the test script is re-executed. It is appended as a new row in the google spreadsheet. If the test fails again, it is again logged into the Incidents tab and the process repeats itself until the test passes. For a test script to pass, all the steps of the test should be executed as it is expected.

- Purpose of testing

-  To check the functionality of the configuration and the code.

-  To ensure that the agreed upon requirements are met by the system's initial build.

-  To help control the actual scope of the project.

-  To confirm that the business process of the client can be supported by the developed system.

-  To gain approval for releasing new functionality.

- Types of Testing

Unit Testing: This test is performed by the Apex developers. This process involves writing clauses or conditions in the code that tests its coverage automatically. It tests the threshold limit of the unit code in a given environment. To deploy the Apex code into production, a 78% test coverage is required.

System Testing: This test is performed by the salesforce consultants. It thoroughly checks the technical processes of the system. It is performed by executing a test script based on specific outputs.

Functional Testing: This is tested by the users of the application. It tests the ability of the system to support the business processes. This test is intended to achieve the client's confirmation on the system. 

Production Testing: This is system test, re-executed in the production environment. It checks if the configuration and the code files have been successfully transferred to the  production environment from the sandbox environment. Also, the User Acceptance Testing is also performed in full scale in the production environment.

Regression Testing

This testing can also be referred to as impact testing by the client. This tests if the newly deployed codes and configurations affect the existing processes of the system in  any way. Many releases of the project may not be intended for all the users. Hence, this test ensures that the process of the users, for whom the new processes have not been made accessible, remain unaffected.

Conclusion:

Salesforce.com Manual Testing use humans as a methodical approach to test while automated testing involves a client recommended computer programs.

Software Testing and its fundamentals.

Software Testing is used to identify the accuracy, completeness and quality of a software application. It executes the software under several positive and negative conditions and checks for its compliance, functionality and performance. 

Understanding Error, Bug, Fault and Failure

The human action that results in an incorrect output  is an error. The presence of error while software execution is called a bug. The state of software with an error/bug is a fault.This event of deviation in software functionality from its intended result is called a failure.

 

Test:

A test is an action taken to find out if something is working as it is supposed to work. It involves simulating situations under  which the object is supposed to work.

Test Plan:

It is a descriptive document where the scope of testing, approach, resources, schedule and its related activities are described. The format and the content of a test plan can differ based on the processes, standards and the testing tools being used.

Test Case:

It is a set of conditions or input parameters which is used while execution. The actual output is then compared with the intended output to determine whether the system works as required.

Test Script:

A test script is used in automated testing. It is a set of instructions which are executed in an application under test. Many test automation frameworks can record/generate the test scripts. 

Methods of Software Testing

- White Box method: Also known as open box testing, in this method, the internal structure of the application under test is known to the tester.

- Black Box method: This is a testing method where the internal structure of the system is not known to the tester.

- Gray Box method: Being a combination of white box and black box testing, here the internal structure is partially known. It implies black box testing with access to the internal resources.

- Agile method: It follows the principles of the agile methodology and testing is carried out throughout the development process.

- Ad hoc method: This refers to random testing without any documentation or proper planning.

Levels of Software Testing

The different levels of softwaretesting are as follows:

- Unit Testing: Here individual methods of the application are tested. It is performed by using the white box method. 

- Integration Testing: Here the individual units are combined and tested as a group. Here, any of the white box, black box or grey box methods can be used for testing.

- System Testing: Here, the complete system is checked. This evaluates the compliance of the system with the requirements specified. Generally, the black box method is used to carry out this test.

- Acceptance Testing: This evaluates the system for its acceptability by checking its compliance level with the system requirements specification. Here, black box method is followed for the testing.

Types of Software Tests:

- Smoke Test

- Functional Test

- Usability Test

- Security Test

- Performance Test

- Regression Test

-Compliance Test

Phases of Software Testing

A software testing life cycle, STLC, defines the different phases in software testing. Although the phases are the same, but their sequence differs as per the Software Development Life Cycle(SDLC) followed and the management decisions. The phases may not be sequential as shown. They may also be carried out in parallel as well. The general phases of any STLC are as follows:

- Requirements Review

- Test Planning

- Test Designing

- Setting up Test Environment

- Test Execution

- Reporting

Conclusion

An effective software testing process delivers quality software which satisfies the user's requirements and expectations. It is an important part of Software Quality Control. With the rise in software competition, the need to ensure quality software is now a priority requirement.

Understanding Software Quality Assurance

Software Quality Assurance ensures that the developed software complies with the specified functional requirements. SQA is a continuous process performed all throughout the Development Life Cycle to check that the software under development meets the standard quality measures. It very clearly and adequately  defines and expresses the problems and their solutions. Its main activities are process definition, process implementation, auditing and training.

 SoftwareQuality Assurance is practiced regardless of the development model being followed. It implements testing methods and checks for the quality of the software in each of its development phase. It involves monitoring and improving the development process and makes sure that the problems found have been dealt with. 

It addresses the following issues:

-          The developed software is a physical realization of the customer requirements.

-          The software can be verified as per the physical realization.

-          The development costs, including testing, debugging and redevelopment are visible and readily categorized.

-          The benefit of the software is visible to its customer/user.

To identify the costs and benefits of a software, a number of software characteristics are defined which have been termed as quality attributes. The common definition of these software quality attributes was developed by Robert Grady at HP. This is known as the FURPS Model. This model has been defined to allow each characteristic of the software to be measurable by Quality Assurance.

The following characteristics have been defined under the FURPS Model.

Functionality: This represents the main features of the software as described in the requirement specification. 

Usability: This includes factors such as accessibility, consistency and interface aesthetics in the user interface. 

Reliability: This considers aspects such as availability, accuracy and recoverability.

Performance: This evaluates aspects such as startup time,  recovery time, system response time and throughput of information.

Supportability:  This supports testability, adaptability, compatibility, scalability etc.

This plan for quality assurance also refers to other development plans of other supporting processes. These different plans include -

1. Documentation Plan

2. Measurement Plan

3. Risk Management Plan

4. Problem Resolution Plan

5. Software Development Plan

6. Configuration Plan

7. Test Plan

A Project Manager may not actually define the project goals, but he ensures that these goals are clearly defined, agreed by the client and included in the Software Requirement Specifications without fail. Having a predefined policy statement of quality, by the development company, also forms the base for these definitions.  These specifications should be defined in quantifiable terms wherever possible. The role and responsibilities of the organization in achieving these goals should also be well defined.

Conclusion

Software Quality Assurance  considers management, development and maintenance plans. It also contains acceptance criteria as well as the reporting activities critical to the software quality. ISO9000 is the international standard used by many companies to ensure that the quality assurance system in practice is actually effective.

Essential Software Test Processes

Software Testing is a process to evaluate a system or its component(s) with the purpose to detect that whether or not it satisfies the specific requirements. Software Testing in simple words is the execution of a system to identify any missing requirements, errors or gaps in contrary to the actual needs or desire. Within the fundamental test process, the activities of analyzing a software item to find the differences between existing and required conditions (i.e. errors/ defects/bugs). In order to achieve Software Quality Assurance to the clients the total testing process goes through the following phases:

Test Cycle:

1. Test Planning 

In this phase the Project Manager decides things to be tested along with the budget. Proper planning at this step can greatly lessen the risk of low quality software. This planning is going to be an ongoing procedure with no end point. Activities at this stage include preparation of high level test plan.

The Software Test Plan (STP) is intended to set the approach, scope, schedule and resources of all testing activities. The plan should identify the items and features to be tested, the types of testing to be carried out, the personnel in charge of testing, the schedule and resources required to complete testing in addition to the risks associated with the preparation. Almost all of these activities are revolved around a software test plan.

2. Analysis and Design

This phase includes the following activities:

- Reviewing the test basis.

The test basis is the information required to initiate the test analysis and create your own test cases. It is basically documentation and test cases such as requirements, architecture and interfaces, product risk analysis and design specifications are based on it. The test basis documents can be used to understand what the system must do once built.


- Identifying test conditions.

- Designing the tests.

- Evaluating testability of the system and requirements.

- Designing the test environment set-up and identifying required tools and infrastructure.

3. Implementation and Execution

At this stage, the test situation is acquired in order to formulate them to test conditions as well as test software to create the test environment. Test implementation and execution is where the most visible test activities are performed and usually involve the following major responsibilities:

- Building and prioritizing test cases, preparing test data, writing test procedures, and optionally, creating test harnesses as well as writing automated test scripts.

- Accumulating test cases into test suites, where tests are run in sequence for efficiency.

- Checking whether the test environment set-up is accurate.

- Running test cases in the determined order, either manually or by means of test execution tools.

- Keeping a log of testing tasks, including the result (success/failure) along with the versions of data, tools, software, and testware such as scripts.

- Comparing actual outcomes with expected outcomes.

- Reporting inconsistencies as incidents in a detailed manner, including preferably causal analysis (inaccurate test specification, code defect, test execution or test data error).

- Repeating test activities where necessary when changes have been made, for instance, re-executing a test that previously failed so as to confirm a fix (retesting), executing a corrected test as well as previously passed tests to verify that defect have not been raised (regression testing).


4. Assessing Exit Criteria and Reporting

In this phase of the fundamental test process, test execution is evaluated against the defined objectives. The activities include the following:

- Verifying whether the previously decided exit criteria have been met.

- Finding out if more tests are required or if the specific exit criteria need changes.

- Writing up the outcome of the testing tasks for the business sponsors as well as other stakeholders.

5. Test Closure Steps

It’s the final stage where test closure activities focus on ensuring that everything is resolved, reports written, defects closed and then deferred for another phase. The test closure spats include the following:

- Making sure the documentation is in order, planned deliverables are properly delivered and all incident reports are determined.

- Finalizing and archiving the test infrastructure¸ test environment and testware used.

- Passing on the testware to the maintenance team.

- Evaluating how Software testing went and learning lessons from this testing project for future releases and projects.