Typically, what are the testing activities that are automated?

With the test automation use on the move, a lot of processes and testing activities are being automated nowadays as far as possible. Test automation has been widely accepted since it is quite an effective testing methodology that can help the software engineering industry to keep pace with this fast paced technology savvy world.  

Usually the processes that are automated include manual processes that make use of formalized testing processes. But besides these, there are many other software development processes and activities that are automated using the test automation and process and the best part is that they do not disappoint the testers.

In this article, we have taken up the discussion regarding the activities that are quite often subjected to automation. These activities are mostly concerned with the test automation. Usually test cases for automated software testing are exclusively written but the test cases for most of the manual testing processes that deploy formalized processes are subjected to test automation in order to save time and efforts both. However, before automating any testing activity it is made certain that the automated tests will be compatible with the system on which they will be run.

Today the developers are forced to develop software systems and applications in quite a small time frame which represents quite a big challenge. There is not only the need of testing the software system or application rigorously but also there is a need to do it as quickly as possible. 

What is automated Testing Life Cycle Methodology?

In order to make the development process quite systematic a methodology has been introduced which is commonly known as “automated testing life cycle methodology” or ATLM in short form. 

The ATLM lays down 6 processes or activities in the process of test automation and many of the sub activities are automate.

1. Decision to automate test: This includes:

(a)  Overcoming false expectations of automated testing.

(b)  Benefits of automated testing.

(c)  Acquiring management support.

     2. Test tool acquisition: 

    This is the second phase of ATLM and involves activities like tool evaluation and selection process. Here the activity tool evaluation can be automated to some extent. While selecting the testing tool it is required that the tester should keep in mind the system’s engineering environment.

    

     3. Automated testing introduction phase: This phase involves the following steps:

   

    (a)  Test process analysis: This analysis ensures that all the test strategies and processes are in one place. The test strategies, goals and objectives are all defined in this phase and are documented. In this phase only the testing techniques are defined and test plans are assessed.

    

    (b)  Test tool consideration: This step involves the investigation of the incorporated automated test tools and their viewing in the context of the automated project testing requirements. Also the mapping of the potential test utilities and tools to the test requirements is done. The compatibility factor of the testing tools with the software system or application and environment is verified and solutions are further investigated.

     4. Test planning, design and development

    5. Execution and management of tests: By this phase the test design and test development has been addressed by the testing team. The test procedures are now ready to be automated. The setting up of the test environment after every test case execution is also automated in accordance with the guidelines. Now the test plan is ready and test environment is also set up, the execution of the test cases is started. This whole process is automated in the favor of the exercising the software system or application under the test.

     6. Test program review and assessment

Explain Extreme Programming XP life cycle?

XP or extreme programming is one of the best agile software development practices ever known since the advent of the agile software development concept. This agile software development methodology was developed with the intention of making improvements in the quality of the software product and responsiveness to the ever changing requirements of the customer. 

Being an agile software development methodology, it involves the frequent releases of the software product in short development cycles (this methodology is called time boxing). This type of methodology is intended to improve the overall productivity and also helps in introducing the check points where new customer requirements can be carefully adopted. 

Elements of Extreme Programming

There are certain elements of the extreme programming few of which are as mentioned below:

1. Programming in pairs.
2. Extensive code review.
3. Unit testing of the whole software code.
4. Avoid programming of the functionality and features until there is an actual need of them.
5. Provides a flat management structure.
6. Maintains simplicity.
7. Maintains the clarity of the code.
8. Expects the changes in the requirements of the customers with the passage of time for the better understanding of the problem.
9. Maintains frequent and effective communication with the programmers, developers and customers.

This article discusses the life cycle of the extreme programming. In the nineteen’s there was a lot of fuss regarding the extreme programming since the environments being adopted for it were quite different from those that were used earlier. 

All the practices of the extreme programming require high discipline making the observers think that the practices are too rigid and should be left unfinished or reduced on the individual sites. 

Extreme Programming Life Cycle

- Simplest example would be of reducing the practice of integration tests to some mutually agreed dates. 

- This helps greatly in coping with the rush of generation of the artificial stubs converting the whole hard process in to a relaxing schedule.

- In this way it will be easy to develop the complex features over a period of certain number of days. 

- Such an approach also helps in investing the development process checking whether or not it is following the right track or not. 

- This development methodology is evolving further till date acquiring an assimilation of various experiences in the field of software engineering. 

- First step in this process is setting up the goals.

- The primary goal is to organize people to produce software productively and with higher quality. 

- Another goal is to minimize the budget of both the money and the time by making use of multiple short development cycles.  

- After goals come the activities. There are four main activities have been defined:

1. Coding: It has been argued over and over that the code forms the most important part of the software development process since no code means no working project.

2. Testing: In testing phase also the XP follows the same philosophy i.e., “if a little can do this much good! More can do much better!” Two types of tests are carried out namely unit and acceptance tests.

3. Listening: This stage involves listening to the customer’s needs and understand what business logic is required.

4. Designing: It involves creating a design structure so that the dependencies withing the program can be avoided.

Explain agile model-driven development (AMDD)?

AMDD stands for the agile model driven development which is not all to be confused with the agile model of software development. The model driven development or MDD is a separate development model and the AMDD i.e., the agile model driven development is its agile version. 

Not many of us familiar with this model. This article is dedicated to the agile model driven development model only. 

About Model Driven Development

- The model driven development involves the creation of the extensive software models before the actual coding is done.

- The best example for this is given by the Object Management Group (OMG’s) model driven architecture standard.

- Model driven development is quite famous with the developers who follow the traditional approaches whereas the agile model driven development has made it mark with the agile followers.

- After going through a research on the RUP/ EUP, it was observed that the model driven development can do with an iterative approach and thus the agile model driven development was born. 

- The basic difference here lies in the creation of the models.

- In the agile model driven development the agile models of the software are created rather than creating extensive models like in the case of the model driven development.

- These agile software models are good enough to drive the whole lot of the development efforts. 

- The agile model driven development is a methodology that has adopted for scaling of the agile software development. 

Activities included in life cycle of an agile project

Below mentioned are the activities that are included in the life cycle of an agile project:

1. Identification of the high level scope
2. Identification of the initial requirements stack
3. Identification of an architectural vision
4. Iteration modelling
5. Model storming
6. Test driven development (TDD)

Iteration activities In AMDD

The following are the iteration activities in an agile model driven development method:

1. Requirements envisioning
2. Architecture envisioning
3. Initial set up and planning
4. Investigative testing
5. Release
6. Production

- The envisioning is done usually in the first week of the development of a software project with the goal of identification of the scope of the software system or application and its architecture. 

- For this both the high level architecture modelling and the high level requirements modelling are required. 

- Envisioning is a means for exploring the requirements and develops a strategy for the development of your project. 

What is to be done in each iteration should be decided well before beginning with the iteration process?

- The agile software development principles insist that the requirements are implemented in the order of their priority levels.

- This is what is called as the iteration planning. 

- For the accurate estimation of the requirement it is required that you understand the work needed to be done for its implementation and this is where the modelling comes to help. 

- The model storming sessions are usually like some impromptu sessions which do not last for more than thirty minutes.

- It involves the discussion over an issue until all the members are satisfied with their understanding of the issue. 

- After this they again get back to coding process. 

- Model storming is often called as the JIT modelling or “just in time” modelling.

- During the whole development process several agile methodologies are followed like:

1. Test first design (TFD)
2. Refactoring etc.

- The above two agile methodologies combined together are known as the test driven development. 

- This is the stage in the agile model driven development where much of the time is spent. 

- Here the detailed modelling is carried out with the help of development tests, customer tests, executable specifications and so on. 

- The customers tests here are nothing but the agile acceptance tests. 

Different Testing activities in Design phase

The design document aids in programming, communication, and error analysis and test data generation. The requirements statement and the design document should together give the problem and the organization of the solution i.e.what the program will do and how it will be done.
The design document should contain:
- Principal data structures.
- Functions, algorithms, heuristics or special techniques used for processing.
- The program organization, how it will be modularized and categorized into external and internal interfaces.
- Any additional information.

The testing activities should consist of:
- Analysis of design to check its completeness and consistency
The total process should be analysed to determine that no steps or special cases have been overlooked. Internal interfaces, I/O handling and data structures should specially be checked for inconsistencies.

- Analysis of design to check whether it satisfies the requirements
Check whether both requirements and design documents contain the same form, format, units used for input and output and also that all the functions listed in the requirement document have been included in the design document. Selected test data which is generated during the requirement analysis phase should be manually simulated to determine whether the design will yield the expected values.

- Generation of test data based on the design
The tests generated should cover the structure as well as the internal functions of the design like the data structures, algorithm, functions, heuristics and general program structure etc. Standard extreme and special values should be included and expected output should be recorded in the test data.

- Re-examination and refinement of the test data set generated at the requirements analysis phase.

The first two steps should also be performed by some colleague and not only by the designer or developer.

Prototyping Software Life Cycle Model - a type of SDLC Model

Prototyping model starts with requirements gathering.The basic idea here is that instead of freezing the requirements before a design or coding can proceed, a throwaway prototype is built to understand the requirements. Prototyping is an attractive idea for complicated and large systems for which there is no manual process or existing system to help determining the requirements.
- Prototype is generally developed at the cost of the developer and not at the cost of the client.
- A prototype is developed using prototyping tools such as scripting languages or Rapid Application Development.
- Prototyping is generally required to obtain user interface requirements.
- In hardware, prototyping is used to prove your design concepts.

Advantages of Prototyping Model

- It is good for developing software for users who are not IT-literate.
- Errors can be detected much earlier as the system is mode side by side.
- Quicker user feedback is available leading to better solutions.
- Reduced time and costs.
- An SRS will be frozen after obtaining the feedback from the user.

Disadvantages of Prototyping Model

- Development cost is borne by the developer.
- Customer could believe the prototype as the working version.
- Users can begin to think that a prototype, intended to be thrown away, is actually a final system that merely needs to be finished or polished.
- Excessive development time of the prototype.
- Expense of implementing prototyping.