=Paper= {{Paper |id=None |storemode=property |title=Agile Software Testing Technologies in a Large Scale Project |pdfUrl=https://ceur-ws.org/Vol-920/p121-koteska.pdf |volume=Vol-920 |dblpUrl=https://dblp.org/rec/conf/bci/KoteskaM12 }} ==Agile Software Testing Technologies in a Large Scale Project== https://ceur-ws.org/Vol-920/p121-koteska.pdf
                               Agile Software Testing Technologies
                                      in a Large Scale Project
                        Bojana Koteska                                                                         Anastas Mishev
     Faculty of Computer Science and Engineering                                              Faculty of Computer Science and Engineering
         "Rugjer Boshkovikj" 16 P.O. Box 393                                                      "Rugjer Boshkovikj" 16 P.O. Box 393
             1000 Skopje, FYR Macedonia                                                               1000 Skopje, FYR Macedonia
                   +38970453393                                                                             +38970330386
    koteska.bojana@students.finki.ukim.mk                                                          anastas.mishev@finki.ukim.mk

ABSTRACT                                                                                process of testing during the agile software development is not
Software testing in agile development is very complex issue in the                      unified and it must be adjusted to the project requirements,
IT world. Since agile methods do not focus much on testing                              organization’s policies and team ability in order to satisfy the
activities and agile software development does not include testing                      customer’ needs.
practices required for a quality project, the process of finding the
suitable method for testing, especially for large scale projects is                                  Table 1: Agile Development Manifesto
challenging. In this paper, we propose a concept of integrated                           Individuals and interactions            processes and tools
agile software testing in a large scale project. This research
                                                                                                                                   comprehensive
explains the software testing process technologies and principles                             Working software
                                                                                                                                   documentation
for agile software testing and identifies the best practices for
testing software products in agile development process.                                    Customer collaboration               contract negotiation
                                                                                            Responding to change                  following a plan
Categories and Subject Descriptors
D.2.4 [Software Engineering]: Software/Program Verification –
Validation, Reliability                                                                 According to agile manifesto shown in table 1, agile software
                                                                                        development adds high value to the left side items. Agile
General Terms                                                                           development approach allows requirements’ changes and it means
Reliability, Verification                                                               that changes can be made also in test cases. That process requires
                                                                                        better communication between developers, testers and end users
                                                                                        in order to overcome the problems and make more flexible and
Keywords                                                                                optimized solutions. The individuals and their interactions are the
Agile software testing, large-scale software project, agile software                    most important part in the project, i.e. the collaboration between
development                                                                             the team members is responsible for better learning environment
                                                                                        where new members could learn things from the senior and most
1. INTRODUCTION                                                                         experienced team members [7].
Software testing should not be defined as a process of finding
errors in the execution of a program, but it should be understood                       Since agile development requires multifunctional teams that
as a mental discipline where test engineers can express their                           follow the principles of iterative and incremental developing
creativity, find the most appropriate testing method or suggest                         practices, the testing process should be efficient and it requires
new testing ideas. Mature organizations have master software                            making tests early and often. There must be clear definition what
testing skills and techniques and they see testing as a mental                          the results of testing should be at the end of each sprint. It means
discipline that can help the all processes in the software lifecycle                    that tests have to be done before the implementation of the project
[1].                                                                                    functionalities in each sprint.

Many mature organizations adopt agile software development                              The key factor of successful testing is close collaboration between
techniques to increase the productivity. The main reason for                            end users, developers and testers. Testers should be part of the
adopting the agile development methods during the project                               development team and all activities must be parallelized as much
lifecycle is to produce higher quality software in less time while                      as possible. For example, while testers are working on test cases,
reducing development costs. However, the most important issue                           developers are coding the user stories. Because the agile
that comes along with the agile software development is testing.                        development paradigm says that all the processes must be done
                                                                                        fast, there is no so much time for testing, so the test data
Agile software development and testing could be easily integrated                       preparation should be done in the planning phase in the
in a small project, but the real challenge for organization is to find                  development process [7]. Better approach is these test data to be
a suitable testing technology for testing a large scale project. The                    prepared together with the stakeholders in order to satisfy the
                                                                                        functional and performance requirements.
BCI’12, September 16–20, 2012, Novi Sad, Serbia.
Copyright © 2012 by the paper’s authors. Copying permitted only for private and         Since iterative development is focused on providing new software
academic purposes. This volume is published and copyrighted by its editors.             at the end of each of the iterations, there must be new software
Local Proceedings also appeared in ISBN 978-86-7031-200-5, Faculty of Sciences,         part with indented functionality. Time required for each of the
University of Novi Sad.



                                                                                  121
iterations depends of the project size and used agile methods, but             Testing methods in agile development processes play an
usually it takes from two to eight weeks. Agile software testing               important role when company wants to offer a quality product.
enables testers to express their creativity and to think in different
                                                                               If team project members want to use agile software testing
directions leading to effective development process and end user’s
                                                                               methods and principles, first of all they must have a vision about
satisfaction [4].
                                                                               what should be achieved and how it can be done in a less time and
The open question here is how to find the most suitable method                 more efficiently.
for testing in agile developing environment. Like we mentioned                 The list below shows the most common principles of agile
before, the process of agile testing is not unified and it requires            software testing [7, 6]:
additional experience and analysis to be performed successfully.
Since agile software development is a high-level framework,                         1.   Agile software testing requires testing in the early stage
every team has to define its own strategies and plans about                              and testing parallel with software development process.
software testing [8].                                                               2.   Testers in the agile software testing team must adapt to
                                                                                         fast changes.
The hardest part is to make testing method ensuring that the
solution of the “problem” in the software development at the                        3.   Customer must be included in testing process in order to
current iteration is done properly. That is the art of the software                      accept the new changes that had been made.
testing where not only formal methods and theory have to be
                                                                                    4.   Testing must be performed at each of the iterations.
included, but the new strategies and ideas also.
                                                                                    5.   At the end of each of the iterations there must be
                                                                                         provided a working version of the software.
2. AGILE SOFTWARE TESTING VS
                                                                                    6.   The process of successful testing requires close
TRADITIONAL SOFTWARE TESTING                                                             interactions between customer and developer in order to
When a company uses traditional waterfall model for developing
                                                                                         save time by avoiding unnecessary re-designs and re-
software, that means that testing is performed at the end of
                                                                                         implementations.
development process. That is the real problem when we talk about
quality software. Testing at the end means increased possibility of                 7.   Progress of the work can be calculated with the help of
errors at the beginning stages. It means that if error is found at the                   planned activities for current period of time.
beginning stage, the stages after it have to be re-evaluated. That
will increase the costs and reduce the time intended for                            8.   Continuous integration is one of the most important
developing.                                                                              steps in agile software testing and development because
                                                                                         the development team should try to provide not only
Agile software testing can help reducing the errors in the first                         functionality of the individual tasks, but the business
stages. The good thing is that agile software testing methods can                        logic.
be included in traditional waterfall developing methods. For                        9.   Testing process should be automated because it will
example, if company has started developing project using                                 provide faster testing results and efficient work
waterfall model, agile software testing methods can be easily                            progress.
adapted to the process [3].
                                                                                    10. Any changes in the process must be accepted by
The main benefit of using agile software testing is reducing the                        customers.
errors in the beginning stages. If we want to provide assurance for            However, using these principles does not guarantee success.
quality, we should test often. Agile software testing methods                  Everything depends on the team structure, project size and
enable testing during all stages and the most important thing is               customer requirements. The key factor for success is the proper
that testing is performed on small units.                                      combination of these principles that will be aligned properly with
                                                                               the company development policies.
Agile software testing is new testing technology that enables
thinking in different directions in order to provide optimized
testing and satisfied customers. Agile testing methods increase the            4. BEST PRACTICIES IN AGILE
efficiency in providing results for a less time. Agile approach is             SOFTWARE TESTING METHODOLOGIES
great approach in many situations but it does not mean that it                 Like we mentioned before, software testing is the core for
should be used anywhere. Development and testing team must                     successful project and satisfied customers. The main question
always decide about method they will use in the development                    here is how to make the process of testing efficient, fast and
process. They must find the most appropriate method that will                  correct. There is not unified process of selecting the proper
guarantee success.                                                             practices when we are talking about best practices, but every team
                                                                               can choose the right ones for the project progress.
3. AGILE SOFTWARE TESTING                                                      The first thing associated with professional testing is professional
PRINCIPLES IN LARGE SCALE PROJECT                                              testers. In agile software development process everyone writes
Agile software developing methods are becoming important part                  tests, so professional testers are required to write more precise and
of the software development evolution process. Leading                         inventive tests, not only to provide more tests. Professional testers
companies in the software industry adopt these methods fast in                 are included to improve the coordination between testers and
order to make their products to be completed early and efficient.              developers also [9].




                                                                         122
Agile testing should be automated. It means that test will be                 developers should also help the process of automation by adding
performed faster and more efficiently. The automation requires                an extra view point in solving problems [2, 5].
selection of the right tool or making own tool to satisfy the
                                                                              One of the most important questions here is how to choose the
projects’ testing needs, to save time and money. If the tool with
                                                                              right tools for automation or how to make an own tool. There are
the requirements for testing the current project could be found in
                                                                              lots of tools in the market, but the team knowledge and
the market, it is wiser to use that tool, instead of making new one.
                                                                              experience should help to choose the right one. Decision depends
Testers should know that not always all testing processes should
                                                                              on project size, time allocated for the project and projects’ costs.
be automated and that some of them cannot be done without
                                                                              If developers and testers cannot find the appropriate tool in the
automation. The challenge is to find a balance between manual
                                                                              market, they can create a new tool which suits their needs for
and automated testing. Agile development requires more
                                                                              testing. If there is already a tool that can satisfy the testing needs
automation of the processes, but it is useful when there is a
                                                                              then it is wide decision to use that tool, instead of making a new
repetitive task or regression testing task. Automation of test task
                                                                              one [2, 5].
that will be used one time is not necessary because it requires
additional time that can be used for making new tests [2].                    The secret for successful testing is focusing on one story at a time
                                                                              and building functionality step-by-step. Continuous integration
The next thing is planning of the quality activities. It means
                                                                              will help to integrate the unit tests and that will improve the
planning for time required for feature and regression testing and
                                                                              process of automation of the tests for next units [5].
also time required for fixing the bugs. In agile software
development time required for testing and coding should be equal.             Automation of testing is not the best solution when making
If team knows that one feature is more difficult than the others,             performance tests. These tests require time and enormous amount
then the time estimated for it should be prolonged.                           of data. If change is made to data model, then it must be
                                                                              propagated to test conditions. This process is difficult, especially
On the other hand, regression testing is allocated as global time
                                                                              when the size of the test conditions is equal to several GB [5].
period because these tests are done in the end of each of the
iterations. Difference in time between the net hours spending on              The real application of automation is in regression testing. These
regression testing and iterations is small and that is the reason             tests are repeatable and they are usually made to simulate user
why time for the regression testing is considered as global.                  actions and check the results. If results are positive, then it means
                                                                              that all functionalities are implemented correct [5].
Time required for fixing the defects is also considered as global.
That is because the time required for fixing the defect and
complexity of the defect could never be predicted. Planning the               5. OPTIMIZATION IN AGILE SOFTWARE
defects is not good idea because we cannot predict a complex                  TESTING METHOD
defect that will require much time to be fixed. The unrelated                 Here are some steps that can help agile software testing in order
defects could require that much time for fixing also [9]. The main            to optimize the process of agile testing:
paradigm in agile software testing about fixing defects is to fix the
defects as soon as possible.                                                       •    Client provides the functional requirements.
                                                                                   •    They are reviewed by the Engineering team (Quality
4.1 Automation of Agile Software Testing                                                Assurance team).
Automation of the agile software testing methods is primary                        •    In the design and implementation phases, user stories
intended to minimize the quantity of manual work involved in test                       are written and they are reviewed by customer.
execution and to gain higher coverage with greater number of test
cases. Automated tests in agile testing developing environment                     •    The requirement specification is updated with the new
are usually unit tests that are responsible for quality of the                          changes.
smallest possible modules [5].                                                     •    When the implementation starts, making the test plans,
This way of testing has a big influence on the tools sets used for                      cases and strategies are being made and all of them
test execution and how the tests are designed. It needs to take                         should be documented properly and reviewed by
advantage of what is already known and develop the practices for                        customer team.
fields where it is not entirely performed.                                         •    During the implementation, testing team determine if
Writing of the tests could be almost a third of testing task. Since                     the testing code could be applied to software code and
the technology for automation has not advanced as expected, the                         that will decrease the potential errors at the start of each
automated test generation tools sometimes generate too large test                       developing iteration.
set which reduces the gains of automation. Anyway there are                        •    The process iterates until the software is fully accepted.
some good techniques and tools that are recognized as fine
                                                                              However, we cannot be sure that the software is 100% error free
methods for the task. It is necessary to understand which of them
                                                                              when handed to the customer. This method is best approach for
are appropriate in what environments.
                                                                              software with requirements that are changed rapidly.
Agile software testing requires automated tools, but testers should
                                                                              There is no need to follow any specific process or method. For
keep in mind that tools must be simple and easy to learn. That
                                                                              different project there should be defined appropriate strategies to
means that tool must be user-friendly and it must provide a simple
                                                                              ensure the system quality. Sometimes, better solution is to use
user interface. Automation of testing requires writing test scripts.
                                                                              heuristic approach that is based on previous test work experience.
All scripts must be prepared well to ensure providing the right
result. Important thing here is to split the long test cases into
smaller because the smaller ones are easily maintained. The



                                                                        123
6. CONCLUSION
Software testing is a mental activity that can be experimented, so
                                                                            7. REFERENCES
                                                                            [1] Ammann, P. and Offutt, J. 2008. Introduction to software testing.
testing can be expressed as a scientific field that can be
                                                                                 Cambridge University Press, UK.
continuously improved. For example, automate tools with an
artificial intelligence, i.e. robots can help the software testing.         [2] Arora, A. 2008. Agile Automation Testing. Adobe Systems India Pvt.
                                                                                 Ltd, Noida.
Agile testing is promising direction, so the future testers must be         [3] Deshpande, S. A., Deshpande, N. A., Marathe, V. M. and Garje G.
more technically professional to develop test stubs and drivers                  V. 2010. Improving Software Quality with Agile Testing.
that interact with more programming languages that will work                     International Journal of Computer Applications, 1, 66-71.
with more complex data sets and to be integrated with agile                 [4] Harish, R., Madhu, B. K. and Lokesha, V. 2012. A Sophisticated
teams. Tools must be highly complex to support the testing of                    Study on Best Practices of Agile Software Testing. International
these data sets.                                                                 Journal of Electronics Communication and Computer Engineering,
                                                                                 3, 26-30.
Testers in agile teams must be professionally educated and                  [5] Jureczko, M. The Level of Agility in Testing Process in a Large
accredited with computer science degree and maybe some courses                   Scale Financial Software Project. In Software Engineering
additionally. They must be concentrated on adding value to the                   Techniques in Progress, Hruska T., Madeyski L. and Ochodek M.,
business software development lifecycle. They should operate in                  University of Technology, Wrocaw, Poland.
position where the combination of their knowledge, creativity and           [6] Madhu B. K., Jigalur, M. and Lokesha, V. 2010. A study on Agile
ability for decisions for testing criteria will be main reason for               Software Testing: Emergence and techniques. African Journal of
success oh the company.                                                          Mathematics and Computer Science Research, 3, 288-289.

The role of automation in agile testing environment will become             [7] Nawaz, A. and Masood, M. K. 2008. Software Testing Process in
                                                                                 agile development. Master thesis. Blekinge Institute of Technology,
more essential and testing and quality assurance will take part of               Sweden.
modern technologies to satisfy the goals new products to the
market rapidly at minimal risk. This kind of system interaction             [8] Puolitaival, O.P. 2008. Adapting model-based testing to agile
                                                                                 context. Edita Prima Oy, Helsinki.
will lead to minimizing the risks and increasing the benefits of
business processes in the companies, that is also the main reason           [9] Talby, D., Keren A., Hazzan, O. and Dubinsky, Y. 2006. Agile
for their existence.                                                             Software Testing in a Large-Scale Project. Software, IEEE, 23, 30-
                                                                                 37.




                                                                      124