Significance of Automated API Testing for Product and Service Companies
Computerized testing is a reasonably unpredictable subject in programming improvement, and its significance is frequently very disparaged. Be that as it may, its actual worth rapidly becomes transparent regarding testing huge items with an enormous number of reconciliations and successive deliveries. The specific purpose of time when QA mechanization turns into a need instead of something ideal to have on a task is measurable. When the joined measure of exertion needed for physically re-testing an item after a delivery exceeds the standard of work that would've been put resources into QA Automation to date, you are managing an undertaking where a QA will be setting aside some genuine cash going ahead. Furthermore, you don't should be most of the way into the task to understand that – a decent QA group will make genuinely exact projections dependent on the current accumulation and the comprehensive data about the undertaking and its design.
One of the zones where QA robotization is, by all accounts, the most regular decision is API trying. We should investigate why.
What's so exceptional about APIs?
Application Programming Interfaces, or APIs, are sets of orders that empower at least two programming frameworks to convey and trade information. Just as correspondence conventions like SOAP and REST, APIs’ development caused it conceivable to coordinate various items to and even effortlessly make completely new application models like SOA.
The entirety of this lead to the production of frameworks involved various subcomponents getting, preparing, and pushing information around as per pre-characterized business rationale. This gave engineers many adaptabilities to reuse the same administrations, guaranteeing administration progression and such, yet also made a significant reliance on the APIs itself. On the off chance that there is a blunder in calls being made to an API or the API itself has changed, the whole framework can get futile until the issue is settled. Furthermore, this is the place where computerized testing sparkles.
As far as QA, testing API's is unique in relation to testing different pieces of a product item since they work on the business layer instead of the introduction layer and don't communicate with clients. No clients convert into less fluctuation in info and yield since we are just keen on calling a specific capacity/strategy and guaranteeing that it restores the right reaction (if by any stretch of the imagination) in a suitable organization. Subsequently, a definitive objective of any QA group is to arrive at 100% API inclusion and have the option to test all combinations with a solitary mouse click in the test suite at any second (after each form and, obviously, after significant deliveries).
Sorts of robotized API testing
Programming interface test mechanization isn't restricted to use testing as it were. Having composed your test robotization system and test contents, you can lead different kinds of tests, the most commonplace of which are:
Burden testing: to discover how well the far off assistance handles an enormous number of simultaneous solicitations and whether it is able or sending reactions back to your application in an ideal way.
Security testing: to check the API for security weaknesses by sending unique solicitations pointed toward trading off its activity or tying down admittance to private information or unapproved zones (entrance testing). Security testing likewise covers territories like client verification, information encryption, and client access control.
Points of interest in utilizing computerized API testing
Programming interface test robotization offers many exceptionally certain advantages to a group of engineers. Most importantly, it drastically rearranges reconciliation and relapse testing in an Agile climate, permitting API calls and combinations with outsider frameworks to be checked each time a critical change is made to the item. If there were an occurrence of complex arrangements, manual approval would require an irrationally enormous measure of time, though, with computerization, it turns into a lot simpler issue to manage.
Quicker and more intensive programming testing implies more limited opportunity to showcase, more limited delivery cycles, quicker criticism, and better variation to clients' necessities, all of which legitimately impact your item’s achievement.
Programming interface test mechanization uncovers incorporation issues over the whole chain of administrations or frameworks, not a confined component just, in this manner sparing huge loads of investigating time and endeavors. You move the entire picture immediately and can make quick moves to apply fixes.
Item organizations are among the top recipients of computerized API tests, significantly if their items depend on outer administrations to get or put away information. Ordinary API tests help guarantee that regardless of whether outside assistance has somewhat altered the configuration of reactions or names of the capacities you utilized, this change will probably be identified even before the first whines begin rolling in from clients.
Computerized API testing is an unquestionable requirement to have a mastery for any developed programming advancement organization. A tremendously proficient and essential resource for useful, burden, relapse, and coordination testing permits QA specialists to chip away at the message and business rationale level to test the usefulness of the framework being grown independently from its UI. As the outcome, the framework’s dependability is consistently checked to guarantee its ongoing activity during creation and long thereafter.
Making Test Class and Method
When a unit test venture is made, a unit test class alongside a test strategy is added to the undertaking. It is possible that we can utilize a similar class or make another by right tapping on Project=> Add=> New Item=> Class. Property [TestClass] for any class decides a class as a unit test class, and [TestMethod] for any technique makes it a test strategy. These qualities are referred to from the library "Microsoft.VisualStudio.TestTools.UnitTesting;"
Understanding the Code
CODE SEGMENT 1: Creating a Client Connection
To perform any API calls, we must open a browser and provide a URL in the address bar. The creation of RestClient in RestSharp is similar to opening a browser and getting it ready to call any server using URL. RestClient initializes a client with the specified Base URI to send requests. In our case the Base URI is http://restapi.demoqa.com/utilities/weather/city. This is called the Base URI because it is the root address of the resource. Adding /Guntur at the end appends the URI’s exact resource name that we are trying to access.
CODE SEGMENT 2: Creating Request from Client to Server
RestRequest restRequest = new RestRequest("Guntur",Method.GET);
As the client is created, it is ready to send any request to the server. So, the request has to be created as specified. RestRequest class creates HTTP Requests against specified URL with a type of Protocol. The above request specifies that it needs to get the information from the URL(Base URL+ “Guntur”)
RestRequest supports creating Request of different HTTP method types (GET, POST, PUT, PATH, DELETE, UPDATE, HEAD, and OPTIONS)
CODE SEGMENT 3: Execute Request on Server
IRestResponse restResponse = restClient.Execute(restRequest);
string response = restClient.Execute(restRequest).Content;
Now that RestRequest object is there, we execute our request to get the server’s resource response. Execute method of RestRequest object actually sends the request to the remote server and gets a response back. This is why the return type of the request.Execute() is specified as IRestResponse.
IResponse interface represents a Response returned from a server. This Response object will contain all the data sent by the server. A different method can be called on the Response object to get different parts. For e.g. call to get Response Headers, Response Status, and the Response Body.
CODE SEGMENT 4: Verifying Response
Assert.Fail("Whether information is not displayed");
Assert class is from Unit Framework is used to verify various assertions.
In our example, we check that weather information is provided as a response from the server for a given city. So if the response contains the city name as Guntur, which confirms proper response is received from the server, else following error message is displayed as shown below:
RestSharp is available as a NuGet package, making it easy to add to your C# project. So, what does an API test written using RestSharp look like? Let’s say that I want to check whether the previously mentioned HTTP GET call to http://api.zippopotam.us/us/90210 returns an HTTP status code 200 OK; this is what that looks like:
Creating data-driven tests
As you can see, creating these necessary checks is relatively straightforward with RestSharp. Since APIs are all about sending and receiving data, it would be good to make these tests data-driven. NUnit supports data-driven testing through the TestCase attribute, and using that together with passing the parameters to the test method is all that it takes to create a data-driven test:
When you run the test method above, you’ll see that it will run two tests: one that checks that the NL zip code 3825 returns HTTP 200 OK, and one that contains that the Latvian zip code 1050 returns HTTP 404 Not Found (Latvian zip codes are not yet available in the Zippopotam.us API). In case you ever wanted to add a third test case, all you need to do is add another TestCase attribute with the required parameters, and you’re set.
Working with response bodies
So far, we’ve only written assertions on the HTTP status code and the content-type header value for the response. But what if we wanted to perform assertions on the contents of the response body?
Technically, we could parse the JSON response and navigate through the response document tree directly, but that would result in hard to read and hard to maintain code (see for an example this post again, where I convert a specific part of the response to a JArray after navigating to it and then do a count on the number of elements in it. Since you’re working with dynamic objects, you also don’t have the added luxury of autocomplete because there’s no way your IDE knows the structure of the JSON document you expect in a test.
Instead, I highly prefer deserializing JSON responses to actual objects or POCOs (Plain Old C# Objects) in this case. The following LocationResponse class can represent the JSON response you’ve seen earlier in this blog post:
Using the JsonProperty attribute allows me to map POCO fields to JSON document elements without names having to match exactly, which is especially useful since some of the element names contain spaces, which are impossible to use in the POCO field names.
Now that we have modeled our API response as a C# class, we can convert an actual response to an instance of that class using the deserializer that’s built into RestSharp. After doing so, we can refer to the contents of the response by accessing the fields of the object, which makes for far easier test creation and maintenance: