Appium Pro is usually known for Appium-related mechanization tutorials and progress techniques. But sometimes it & # x27; s good to tread rearward and take a expression at the bigger painting of how these techniques are used, which is well-nigh frequently in the context of & quot; testing & quot;. In my forthcoming line on HeadSpin University,, I mouth a lot about testing, and what it is, before diving into any automation training. I think it & # x27; s always useful to consider our practices from a philosophical perspective before simply plowing onward, and so this clause is a snippet of the trend which has to do with precisely this question: what is screen?

I reckon we would all have a fairly full intuitive mind of what testing is. It & # x27; s making sure something works, flop? Indeed! But as a former polyglot, I think it & # x27; d be great to dive a bit into the etymology of try, the background and history of the news itself, to get a sense of the roots of the conception.

Check out:

The Etymology of Testing

The English word & quot; examination & quot; originally came from a Latin tidingstestum, which referred a form of container or pot make of earth. These were pots that were designed to hold rattling hot metal. People wanted to heat alloy up for a number of reasons, but one was to determine whether there were any impurities in the metal.

So, by association, the pot itself became tied up with the act of checking the quality of the metal, and so now we can say that to put something to the examination, i.e., to heat it up in the earthen pot called a & quot; testum & quot;, is to determine the quality of whatever that thing is! You might also hold see someone talk about a & quot; crucible & quot;, or maybe heard the expression & quot; depart through the crucible & quot;. This is another word that has a very similar history. A & quot; crucible & quot; is another kind of container for heated metal! To take our analogy a bit deeper, we can say that & quot; testing & quot; is the process of applying some form of energy in some variety of container to determine the quality of something we like about.

Also check:

Testing Software

Now, what wecare about is software. Our job as testers is to get some sort of denotation of the quality of the software that sits in front of us. Maybe we developed it ourselves, or peradventure person else did. How do we even start believe about the process of test software? There are a huge bit of methods and creature that we can use in the process. But one mere way of cerebrate about it is recognize that our province is to design and bring about the specific conditions (like heating a pot) that will reveal the character of the package. One mutual way of play about these conditions is to use the software in its normal manner, as a normal user. The software is intend to run in certain weather, and we can simply run it in those conditions, as any normal user of the software would, to determine whether it act the way it & # x27; s supposed to in those conditions.

For autonomous testing across multiple user personas, check out SUSATest — it explores your app like 10 different real users.

Read:

We could alsotry to think conditions for the package that its developers might not feature thought about. These are oftentimes called & quot; edge suit & quot;. The trouble with software is that there can be a near countless number of conditions a piece of software runs in, and a near infinite act of situations or states it can get itself into, based on user stimulant or early component. When developers write software, they usually assume a fairly elementary and minimal set of conditions. It is the job of a examiner to design crucible, or tryout scenario, that show how the software deport in all kinds of situations.

Obviously, if there are an infinite number of situation that software can get run in, it doesn & # x27; t make sense to try and examine every possible case. So test becomes a real mix of engineering and creative, out-of-the-box thinking, simply to figure outwhatto prove. And that is exclusively the beginning! Testers don & # x27; t feature an infinite amount of time to evaluate each possible release of package. Sometimes software gets released multiple times a day! Choices have to be made about what & # x27; s most crucial to screen, and which additional tools and strategy to assume to make sure that as much as possible can be examine.

Also read:

Imagine if you were an ancient Roman quizzer, and people wreak their metal to you to heat up and determine its quality. Once the metal part stack up faster than you can gather logarithm and heat up your pots, you & # x27; ve got a problem, and you demand to figure out not just new and canny methods for determining the calibre of the metal, but also the mechanics of how to scale your testing recitation. Maybe you buy more pots, or invest in engineering that starts fires quicker. Maybe you get first-rate advanced and build out that by integrate certain reagents in with the metal, you can get an instant read on one aspect of the caliber of that metal! Anyway, I don & # x27; t want to push this analogy too far. But this is very much the situation encountered by testers. Almost all testing of software nowadays is done in a context that requires outstanding breadth, depth, hurrying, and scale. It & # x27; s an impossible set of requirements, unless testers adopt some of the same modes of thinking that get propelled software development to Brobdingnagian grade of scale.

And yes, by that I mean automation, which is a conversation for another clip. The main takeaway for now is this: examination is a recitation which uses creativeness and technology to construct and execute special crucible for package, with the goal of determining the caliber of the package to as accurate a degree as possible!

Check out:

Kinds of Testing

So, we specify testing as follows: the act of defining, building, and executing summons that determine coating quality. This is a full definition, but it & # x27; s pretty general. We can get a lot more specific about the assorted types and subtypes of testing, so we cognise what kinds of options we have when it get to defining and building these trial processes.

The way I like to think about types of testing is as a 3-dimensional matrix. Each attribute tally to one facet or characteristic of a examination. Here are the three dimensions that I see:

1. Test targets. A test target is basically the thing you want to test! We might call it the & quot; object under test & quot; to be general. In package examination, it & # x27; s usually called the & quot; App Under Test & quot;, sometimes written AUT. But target means more than saying what app you & # x27; re testing. Usually, we & # x27; re only responsible for testing one app anyway, so the App Under Test is kind of a given. What I mean by & quot; target & quot; is, whatcomponent or layerof the app is being quiz. When we develop software, the package usually has a number of discrete components, and a number of discrete level. We can deal the degree severally, and even test them independently if we want. One component or level of an coating could be an individual code function. Users don & # x27; t execute individual code purpose -- -that happens behind the scenes, so to verbalise. But we could test a specific function in isolation! Another stratum could be the layer of an application & # x27; s API. Again, user don & # x27; t typically try to access an app & # x27; s backend API. That & # x27; s something that the app itself would do in order to furnish the appropriate information to the user. Yet another layer could be the user interface or UI of the app. This is the part that a exploiter really interact with! And we could test all of these different layers. We could test individual units of code. We could test APIs. We could test integrations between several backend services. And we could test the UI. That & # x27; s what I mean by & quot; target & quot; -- -the test target is the answer to the question, what vista of the app itself are you trying to quiz?
2. Test types. Now here I mean something very specific by the word & quot; type & quot;. In this sense, I intend, what view of the app & # x27; squalityare you trying to test? Apps can have good or pathetic quality on a number of different dimensions. One app might be fast but perform computation incorrectly. So, we would say that it has good execution but poor functionality. Another app might feature good performance and functionality but be hard for people who are hard of hearing to use. Then we would say that app has poor accessibility. Performance, functionality, and accessibility are all aspects of the character of an app. As apps become more and more important in our lives, we keep coming up with more and more aspects of app quality that become crucial! If we require to test all of these categories, I would say we desire to implement a number of different testtypes. So that is what I intend by & quot; type & quot;.
3. Test methods. This category is a bit more straightforward. Basically, method merely refers to the procedure utilize to implement the test. How will the test be execute? That & # x27; s the method. What are some methods? Well, what we telephone & quot; manual examination & quot; is one method. Manual testing is simply the act of using an app the way a exploiter would, or practise an app component in a one-off way. In former words, it & # x27; s done by hand, by a human being. You can manually quiz units of code. You can manually test APIs. And of course, the near common instance of manual testing is manual testing of app UIs. But manual examination isn & # x27; t the lone method. We can also write package to try our app under test. In this causa, our tests are see to be using theautomated method.

So, this is the construction I use to help give us an understanding of the various types of tests. These are three dimensions, meaning that in principle the test target are self-governing from the test types, and they & # x27; re both independent from examination methods. In drill, not every potential combination of those three property ends up create sense, but a lot do. Let & # x27; s look at some examples!

Unit Testing

The name & quot; unit testing & quot; refers to the idea that we are quiz a specific unit of codification. can be described using the different test dimensions in this way: the & quot; target & quot; of a unit test is typically a individual function in the codebase. The & quot; type & quot; is usually silent to be functionality. Usually when pen unit tests, we are making sure that the specific bit of codification in question function appropriately, in price of its input and outputs. Wecouldrun other types of tests on individual code map, for example we could test their execution. But usually unit examination are write to. And the & quot; method & quot; for a unit test is unremarkably automation.

UI Testing

UI Testing go under many different names. Sometimes it & # x27; s called & quot; & quot;. Sometimes it & # x27; s just called & quot; functional examination, & quot; and some citizenry still refer to UI tests when they mouth about & quot; integration tests. & quot; I imagine most of these other names are a bit confusing, so I prefer to use the term & quot; UI Test. & quot; This do clear what the quarry of our examination is: it & # x27; s the UI of an application. As we verbalize about earlier, an app has many different stratum, but users typically simply interact with the UI. When you are doing UI testing, you are running tests from the perspective of the user! Now, & quot; UI & quot; just refers to the target of quiz, and it doesn & # x27; t specify the type or method involved. Typically, if we don & # x27; t say anything else, is assumed to be functional in nature. That is, we are try the UI & # x27; s functionality. And of course, we can do this employ different methods, whether manual or automated.

Integration Testing

Another type of screen which is commonly discussed is & # x27; integration testing & # x27;. Sometimes, when people say & quot; desegregation testing & quot; they might mean & quot; UI prove & quot; so it & # x27; s good to make certain everyone & # x27; s work with the same definition. WhenIsay integration testing, what I mean is testing the communication, or & quot; integration & quot;, between two different services. Let & # x27; s go back to the 3-dimensional framework we & # x27; ve been using to unpack this a slight bit. In terms of a mark or targets, integration testing is focused on two constituent of a larger scheme. In the world of modern software development, the almost obvious candidate for these constituent would be a set of microservices that all communicate in order to power an coating. But the portion don & # x27; t necessarily need to be free-standing services; they could too just be two ball of a much larger monumental codebase, which are responsible for transmit in some way. The test & quot; type & quot; I mean when I talk about & quot; integration testing & quot; is usually & quot; functional & quot;. We could do performance integration testing, but it & # x27; s usually adopt that we & # x27; re merely talking about create sure the integration works at all. Finally, the test & quot; mode & quot; can be manual or automatize, just like any former form of quiz we & # x27; ve discussed, but this kind of testing is almost always automated.

A good example of integration testing would be asserting that two services convey with one another correctly, even if the entire stack is not in the painting. Maybe you have one service that reads customer orders from a task queue, make some processing on them, and then sends certain orders to a system that is responsible for physical order fulfilment (in former words, shipping), and sends other orders to a system that is responsible for digital order fulfillment (in early words, e-mailing digital production or something like that). You could picture setting up a test environment that just runs these few services, and has no frontend, and no actual real database or project queue. Fake orders can be created in a bare in-memory queue, and orders received by upstream services can simply be included in a rightness assertion, but not actually acted on. This would be an example of an integration exam.

Conclusion

There are wad of other kinds of testing out there, but I hope that you remember the three dimension we can use to define any type of prove: the testtarget, the testtype, and the testmode. The target specifies what thing we & # x27; re trying to ensure quality for. The type define what form of quality we wish about (speed, rightness, visual charm, etc ...). The mode delimit how we go about the test (do we use automated means, or manual means, or some specific subcategory of those?). Take a moment and think about the various examination you & # x27; ve written in your career, and try to map them on this outline.

4 Parts

Connet Now