Integration Testing - Reading Assignment

[Kamlesh_Joshi]

1. to check all the the units, componets or modules work fine together as whole
   2)Requires all units or complete application and then only tests could be run, requires time
   3)in top down testing is done from top modules to lower modules, requires more time, prototype can be created early, time consuming,tester checks important units first. In bottom down lower modules are tested first and then top modules. It takes less time, prototypes cannot be created first, critical modules are test last, multiple lower unit may make it complicated, less time consuming

[levinardo]

1. Why do we write integration tests?
   This is to test that the overall source code works as intended, especially when different teams write different units of the codes.
2. What problems do integration tests solve?
   Interface between units that may not be resolved solely by unit testing. Also this allows testing gaps for updated units / piece of codes.
3. What are the differences between top-down and bottom-down approaches?
   Bottom-up approach will focus from the smallest piece of code and then move up in the integration hierarchy. Meanwhile, Top-down approach will focus from the overall integrated systems and then dig-down into the lower level of the code into the units. The Bottom-up approach will require all modules to be completed first before the integration testing can be performed.

[Den_Wal]

• Why do we write integration tests?
  It tests the entire code with all the units as a whole and sees if there are any issues which occur once all the units are linked together.
• What problems do integration tests solve?
  It test the errors that would only appear when you link all units together and run the application.
• What are the differences between top-down and bottom-up approaches?
  Top down approaches start at higher levels of the software and progressively work down to lower more basic units of the code. Bottom-up approaches are more expensive, and take a longer time but go through the errors more thoroughly beginning from the single units upwards the entire code.

[Big_G]

1. Why do we write integration tests?
   To test the interface between the modules and expose any defects that may arise when these components are integrated and need to interact with each other.
2. What problems do integration tests solve?
   It ensures that the integrated units function properly as one unit and align with stated
   requirements and ensures no errors between the different interfaces of different modules.
3. What are the differences between top-down and bottom-up approaches?
   Top-down starts testing with the higher-level modules and works its way down to the
   lower-level modules, while Bottoms-up is the opposite.

[a.l.a.i.n]

1. To test the interfaces between the modules and expose any defects that may arise when these components are integrated an need to interact with each other
2. It solves problems that may occur after bringing the different units together. It solves problems that may occur when requirements change later on. They solve problems that may occur by using APIs or other common issues like inadequate exception handling, API response generation, data formatting, erroneous external hardware interfaces, incorrect third-party service interfaces and error trapping
3. Top- down testing approaches the highest level module first and works its way down to the lower modules while Bottom-up testing is the opposite.

The advantages and disadvantages of top down testing :

Pros:

It is easier to identify defects and isolate their sources.

Testers check important units first, so they are more likely to find critical design flaws.

It is possible to create an early prototype.

Cons:

The examination of lower-level modules can take a lot of time, so testers may not test them adequately or completely.

When too many testing stubs are involved, the testing process can become complicated.

And for bottom up testing:

Pros:

It is easier to find and localize faults.

Less time is needed for troubleshooting since testers don’t have to wait for all modules to be available for testing.

Cons:

Testing all modules can take a lot of time, so there may be delays in releasing the final product.

Critical modules are tested only in the final stages, so testers may miss some defects and developers may not have enough time to fix found defects.

Testing can be complicated if the software consists of multiple low- level units.

It is not possible to create an early prototype.

[rhysjharry]

1. To test the interfacing or interoperability between the component of code when running together

2. Communication bugs maybe caused by different programmers or companies applying different
   styles or techniques with code. To pick up interfacing errors unit testing might not.

3. Top down starts with larger components through to smaller. I guess the advantage here would be
   to error proof more code at once saving time and costs. Bottom up is the opposite, the downside
   being it is more detailed and therefore more time consuming and then costly but the benefit would
   be a more accurate way of finding problems which may save time and costs in the long run.

[dennisdoan]

1/ integration tests aim is to test the interfaces between the modules and expose any defects that may arise when these components are integrated and need to interact with each other.

2/ Integration tests identify problems with the way different program components interact with each other.

3/ The bottom-up process starts with unit testing followed by progressively higher level tests of combinations of units. Top-down integration testing, the highest-level modules are tested first and progressively lower-level modules are tested thereafter.

[Maia]

1. Why do we write integration tests?
It is written to evaluate the interaction between the unit codes and confirm data is interacting in formats that each side can understand.

2. What problems do integration tests solve?
It helps to identify integration issues between modules, it ensures that integrated modules work properly before moving to complete application (which include finding bugs earlier in the test phases) and finally, it provides better test coverage and additional level of reliability.

3. What are the differences between top-down and bottom-up approaches?
Top-Down Testing starts from top-level modules towards the lower-level modules and stubs may be used in case of modules not being developed at the time of testing.

Botton-Up Testing starts from lower-level modules, moving upwards to the higher-level modules and drivers to simulate the functionality of higher-level modules to test lower-level modules may be used.

[BittMark]

1. These tests are written to expose problems with the interfaces among program components before trouble occurs in real-world program execution

2. They identify problems with the way different program components interact with each other

3. The top-down approach is an incremental approach that involves testing from the topmost or highest-level module and gradually proceeding to the lower modules. Bottom-up integration testing is the opposite of the top-down approach. It involves testing lower-level modules first, and then gradually progressing incrementally to higher-level modules. This approach is suitable when all units are available for testing.

[dbleal]

@ivan

Welcome to the discussion about this reading assignment.

Leave your answers to the questions below in this thread. If you have any questions or you want to discuss something connected to the assignment feel free to do it in this thread as well, but please everything to the topic.

1. Why do we write integration tests?
2. What problems do integration tests solve?
3. What are the differences between top-down and bottom-up approaches?

• to verify if the individual units are communicating with each other properly and working as intended post-integration
• expose any defects that may arise when these components are integrated and need to interact with each other.
• The top-down approach is an incremental approach that involves testing from the topmost or highest-level module and gradually proceeding to the lower modules. Each module is tested one by one, and then integrated to check the final software’s functionality; the bottom-up approach it’s the opposite and it’s suitable when all units are available for testing.

[TheOldOne]

1. Why do we write integration tests?
   to test the interfaces between the modules and expose any defects that may arise when these components are integrated and need to interact with each other.
2. What problems do integration tests solve?
   interoperability between systems to expose problems with interfaces among program components before they even occur.
3. What are the differences between top-down and bottom-down approaches?
   Top-Down starts with high level functional test cases, whereas Bottom-Up testing begins with unit testing.

[SDMRDEL7890]

Why do we write integration tests? :

Because we want test the all the code that makes up the application and also all the interfaces linking all the components together.

What problems do integration tests solve?

Interoperability between systems, to expose problems with the interfaces among program components before they occur.

What are the differences between top-down and bottom-up approaches :

Top-down starts high level functional test cases, or user scenarios. Bottom-up integration testing begins with unit testing, followed by tests of of progressively higher-level combinations of units called modules or builds.

[flrnblock]

1 - To test the interfaces between the modules and expose any defects that may arise when these components are integrated and need to interact with each other.

2 - It’s the step that comes after unit testing. It allows to test the behaviour of a combined or integrated unit and verify if the individual units are communicating with each other properly and working as intended post-integration

3 - The two approaches are the opposite.
The top-down approach involves testing from the topmost or highest-level module and gradually proceeding to the lower modules whereas Bottom-up approach involves testing lower-level modules first, and then gradually progressing incrementally to higher-level modules.

[M_Alex]

1. Why do we write integration tests?
   Because we need to test the interfaces between the modules and expose any defects that may arise when these components are integrated and need to interact with each other.

2. What problems do integration tests solve?
   Integration testing identifies these errors in how different modules are integrated and interact with each other and ensures that these modules work well together after integration.

3. What are the differences between top-down and bottom-up approaches?
   Top-down testing involves testing from the topmost or highest-level module and gradually proceeding to the lower modules. Each module is tested one by one and then integrated to check the final software’s functionality.
   Bottom-up integration testing involves testing lower-level modules first, and then gradually progressing incrementally to higher-level modules.

[Rickspider]

1. To ensure our modules work as one. A unit is the smallest piece of working code, and a module is the sum of many units working towards one of the softwares goals. You need to take said modules and run them together to make a functional product, and this oftentimes can cause a whole iota of bugs. This is why we test them: To make sure it all works.

2. Communication mistakes between modules, such as developers being “lost in translation” with eachother. As code is personal, one persons understanding sometimes differs wildly from anothers, so you need to smooth those out.
   It all mostly comes down to fixing pieces that dont “match”, for some reason or another.

3. Top down approaches attempt to fix critical modules first, testing them from higher-priority to lowest. This is the best approach if you need to whip up a prototype, or an alpha build, as all of the critical functions to your code will be tested first.

Bottom up is a more detailed way, as you fix the least important modules (or lowest priority) until the critical ones. This ensures that you’ll be paying attention to minimal details, but it also means you cannot create a working prototype and will likely take a longer time to be able to release your product.

[ShreyPanda]

• Why do we write integration tests?
  To test all the code that makes up the application and all the interfaces that link its components.

• What problems do integration tests solve?
  They spot errors that occur in the entire application, test subsystems and check if interfaces are working correctly by themselves and collectively.

• What are the differences between top-down and bottom-up approaches?
  Top-down testing= Starts testing at higher levels of the software and then moving to lower levels of the code
  Bottom-up testing: Starts testing at low level components and progresses to higher levels.

[Selim]

hi everyone,

1. To check that the combination of modules/units put together work well
2. You may have your individual modules/units working fine when tested separately but the way they are put together may have a problem, that is what integration testing will find and help testing. Given the final of the champions league is tomorrow: take Benzema, take Van Dijk, great players, they will do great if you check separately. But you put them together and do the mistake of putting Benzema as a defender and Van Dijk as the striker, maybe it s not the best combination, you may realise with integration testing the reverse works best.
3. You start with higher levels of testing first and progressively testing the lower levels after in the top down approach while you do the reverse (lower levels first) in the bottom up approach.

[gunnarseay]

1.) We write integration tests to be able to deploy an entire application with good performance. All peripheral units need to be tested and then brought together to get a real idea of how the application is going to perform.
2.) Integration tests solve problems such as: integrating disparate modules from various developers into an overall application, ensure that changing requirements are incorporated into the application, eliminating common issues missed during unit testing, and any fixing any other problems that might arise in the big-picture application.
3.) The difference between top-down and bottom-up testing approaches is that a top-down testing approach involves testing from the topmost or highest-level module and then proceeding to lower modules (each module is tested one-by-one to incorporate into the final software’s functionality). The bottom-up testing approach, on the other hand, involves testing lower-level modules first to progress to the higher modules (which is suitable when all units are initially available for testing).

[Mroman]

I was not able to read the article, it keep asking me for corporate addres. My email did not worked.

[cotts31]

1. Why do we write integration tests? Integration testing can help ensure that the integrated units function properly as one unit and align with stated requirements. It can also ensure there are no errors between the different interfaces of different modules.
2. What problems do integration tests solve? It helps determine if the application is functioning as it should. They help determine if there are issues by testing the entire system as a whole
3. What are the differences between top-down and bottom-down approaches?
   Top down focuses on testing the highest level modules first and working the way down from there. Testers check the most important modules first so they can most easily find flaws, but testing the lower level areas can prove more difficult and time consuming.

Bottom up is the opposite. It’s easier to find and localize faults when using the bottom up approach as you’re more so looking at it piece by piece similar to unit testing