Integration Testing - Reading Assignment

[Lacho]

1. Why do we write integration tests?
   Because, it can expose problems with the interfaces among program components before trouble occurs in real-world program execution. Integration testing is a component of Extreme Programming (XP), a pragmatic method of software development that takes a meticulous approach to building a product by means of continual testing and revision.
2. What problems do integration tests solve?
   Integration testing can expose problems with the interfaces among program components before trouble occurs in real-world program execution.
3. What are the differences between top-down and bottom-down approaches?
   Bottom-up integration testing begins with unit testing, followed by tests of of progressively higher-level combinations of units called modules or builds.
   In top-down integration testing, the highest-level modules are tested first and progressively lower-level modules are tested after that.

[Gus]

1. Once the units have been tested, the next steps are to test functional groups to ensure their correct interoperation.
2. Integration testing validates the functional requirements of the modules. Most modules use the output of other modules as their input, and therefore they need to be tested in their operational specifications.
3. In top-down testing the higher-level modules are tested first and then the testing comes down the branch until it reaches the lowest level. In bottom-up testing, the lower level groups are tested first.

[Adam1]

1. integration tests exist to expose problems with interfaces among components.

2.integration tests stop the problems from happening in the real world.

3.the bottom up testing starts with the least important items and the top down testing starts with the most important items.

[Cryptoshi007]

@ivan

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

Response:

1. Integration tests are written to catch bugs and errors before the program goes live.
2. These tests try to expose interface issues; try to imitate real-world scenarios that the users, computers, system and network may experience.
3. Top-down begins at the highest level module and works backwards; bottom-up starts first with unit testing then builds up to the highest level.

[javier_ortiz_mir]

1. Why do we write integration tests?
   So that we can test and find any problems with interfaces or different software modules.
2. What problems do integration tests solve?
   They can find issues before trouble occurs in a real world execution.
3. What are the differences between top-down and bottom-down approaches?
   With the top down approach you would start with tha main funcitons and progressively lower level modules after that. With bottom-up approach you would start with unit testing and progressively with higher level tests

[tuchtech1]

• Why do we write integration tests?
  Integration tests are run to look for problems in software module [unit] connections and data transfers.
• What problems do integration tests solve?
  Integration tests make sure that all software modules communicate effectively.
• What are the differences between top-down and bottom-down approaches?
  The top-down testing approach starts with the end result [highest level module] and goes back through the system to the beginning, while the bottom-up approach starts at the beginning with low level modules and works its way through to the end and highest level module[s].

[D1alZer0]

1. We write integration tests to make sure that the individual units and modules work together correctly and efficiently.

2. Integration testing can expose problems with the interfaces among program components before trouble occurs in real-world program execution.

3. Bottom-up integration testing begins with unit testing, followed by tests of of progressively higher-level combinations of units called modules or builds. In top-down integration testing, the highest-level modules are tested first and progressively lower-level modules are tested after that.

[VanellaVader]

1. So that problems with the components of an application can be spotted before real-world testing is done
2. Integration testing is critical for exposing problems with the interface between different components of an application.
3. Usually bottom-down testing is done first, and it usually begins with testing the smallest components and slowly building upon them, integrating them in different ways. Top-down testing begins with modules and progressively breaks them into units.

[Wxdoc]

1. Integration Testing is defined as a type of testing where software modules are integrated logically and tested as a group. The purpose is to make certain that the integrated modules are functioning as intended. This type of tests exposes defects in the integrated modules. The test checks data communications among the modules.

2. Integration tests solves the interoperability issues of modules, as data communication amongst the modules is of paramount importance for accurate functionality.

3. Top-down approach starts analysis from the top module to the bottom module. The bottom-up approach is from the bottom to the top of the modules.

[JCrypto]

1. We write integration tests to solve potential problems while the software is still in the developmental stage, especially as they relate to all the interfaces.

2.Integration tests identify bugs early on before they can cause wider problems in the real world

3. In top down integration testing, the highest level modules are tested first and progressively lower level modules are then tested after that. In bottom up testing it is the reverse, where the process begins with a unit and then graduates to higher level combinations.

[dextro]

Reading Assignment: Integration Testing

@ivan

• Why do we write integration tests?

Integration tests allow us to confirm individual components interact as expected. How the program responds to input from users or interacts with other systems.

@ivan

• What problems do integration tests solve?

Integration tests catch problems between components that unit tests may not find.

@ivan

• What are the differences between top-down and bottom-down approaches?

In the top-down approach tests are built against the highest level modules first, then “down” towards individual components (unit testing). The bottom-up approach means building unit tests first and working “up” towards testing the higher level interactions/modules.

[Kim]

1. Why do we write integration tests?
   So that program units are combined and tested as groups in multiple ways.
2. What problems do integration tests solve?
   It can expose problems with the interfaces among program components before trouble occurs in real world program execution.
3. What are the differences between top-down and bottom-down approaches?
   Bottom-up integration begins with unit testing, followed by tests of progressively higher-level combinations of units called modules or builds .
   In top-down integration testing, the highest level modules are tested first and progressively lower level modules are tested after that.

[ChefAbate]

1. Integration tests are written to ensure all separate parts of a project work together.
2. Integration tests find any errors in code between all of the systems and subsystems communicating between each other.
3. Bottom-up approach confirms that each individual component works correctly, top-down approach tests the application as a whole to ensure the system works together. The bottom-up approach should be used first because if you do the top down approach it will be difficult to find where the error is coming from.

[crypto_j55]

1. Why do we write integration tests?
   Answer: Integration tests are meant to find issues that may arise in real-world program execution. These tests will often run the app from start to finish (i.e. complete an entire order), so that it can test API calls to the DB, the app, or web services.

2. What problems do integration tests solve?
   Answer: They identify problems with various components of an application that interact with each other.

3. What are the differences between top-down and bottom-down approaches?
   Answer: Top down refers to testing the highest level modules of the application first, where as bottom-up approach refers to focusing on the lower-level individual components first (i.e. DB interaction, individual API calls).

[Jun_0113]

1.Why do we write integration tests?
-> To make sure the system works as a total system not only parts.

2.What problems do integration tests solve?
-> It solves to verify that the functions which uses multiple different units.

3.What are the differences between top-down and bottom-down approaches?
->bottom-up is starting by checking all the smallest units work as planned. And top down approaches start from checking the whole system from the beginning of the system.

[BERGLUND]

1. Integration test aims to test how well the units work together.
2. There might be problems with the interface, you will not find at the unit level.
3. Top-down: you start with a complete app and if the test fail, you remove units until you find the problem(s). Bottom-up: you add units to the app until it fail or is complete.

3 top-down is well known, bottom-down is not so known.

[R.C]

1 because when integrated to verify that they work as expected, that is, to test modules that are working well individually, there are no problems when integrated.
2 find errors in the individual modules
From top to bottom, testing begins at higher levels of the software, and then tests lower and lower levels of code. Bottom up starts at the lower or lower level components and moves up.

[Samuel_Inclan]

Why do we write integration tests?
It is important because it is the next step in unit testing. tests are carried out to see how a unit interacts and works with the different parts of the system to avoid future errors.

What problems do integration tests solve?
Problems related to the interaction and execution between different units of the system.

What are the differences between top-down and bottom-down approaches?

In top-down testing, the highest-level modules high functions are tested first and progressively lower-level modules sub functions are tested after.
The bottom-up process starts with unit testing followed by progressively higher level tests of combinations of units otherwise known as builds star with modules that you later integrate with main functions.

[soko]

1. Why do we write integration tests?

To test the functionality of the software

2. What problems do integration tests solve?

It can expose problems with the interfaces among program components before trouble occurs in real-world program execution.

3. What are the differences between top-down and bottom-down approaches?

They both test the functionality of the software, but they cannot replace one another. The bottom-up testing begins with unit testing of progressively higher level combinations of units called modules or builds

When it comes to top-down testing the highest level modules are tested first and then progressively lower levels modules.

[Rodbstarr]

1. It helps to figure out the potential problems that can happen and what steps to come up with a solution.

2. helps figure out any issues between systems.

3. The differences between top-down and bottom-down approaches is that top-down starts at top layer part of the software where as the bottom-down start at the low level part of the software. Taking these (2) approaches help identify faster where the problem may be coming from.