Category: Saas App

Why do we need Unit testing?

● The developer knows where our code “breaks” as compared to the tester, so while developing if we implement Unit testing then we can improve code quality, so this will help in reducing bug-fixing, cost and time.

● If we ignore Unit testing it leads to higher defect fixing cost and time during System Integration and Beta testing after the application is completed. Proper unit testing done at initial stage at developer’s end saves both time and money.

What is Unit testing?

Testing an individual unit, such as a method (function) in a class, from other modules of your application. A Unit test doesn’t test the whole module; it tests the smallest unit that makes up a more significant module

Advantages:

• With Unit testing, the speed of development will be faster.
• Traditional testing involves setting breakpoints, debugging the code and providing inputs through GUI(Graphical User Interface). But Unit testing will simplify testing without GUI.
• It takes less time to find and fix the bugs during Unit testing.
• Reusable codes also reduce the effort and save time as the code needs to be modular in Unit testing and also bugs are fixed in the initial stage.

Disadvantage:

• It cannot catch broad system errors or integration errors.

Different frameworks available in market for Unit testing:

1. MSTest – It is an in-built testing framework provided by Microsoft.

2. NUNIT – It is an open-source testing framework that is entirely written in c#.

3. XUNIT – This framework supports programming language i.e JUnit for java and .net.

Let’s do a quick comparison to evaluate better framework:

NUnit VS MSTest:

• Nunit contains an [TestCase] attribute that allows implementing parameterized tests. This feature is not available in MSTest
• MsTest’s ExpectedException attribute is a bug where the expected message is never really asserted even if it’s wrong – the test will pass.
• NUnit contains an articulate version of Assert API (as already mentioned – Assert.That..)
• Nunit is much faster
• NUnit can run tests in  both versions like 32 and 64 bit (MSTest only runs them in 32 bit IIRC)
• NUnit allows an abstract set of classes to be test fixtures (so you can inherit test fixtures). MsTest does not contain test fixtures.
• NUnit contains PNunit (running parallel tests with NUnit). MsTest only adds this ability in visual studio 2010 IDE

How to integrate NUnit Framework?

NUnit – provided by Microsoft.NET  open-source Unit testing Framework. It provides a rich set of assertions as static methods of the Assert class. NUnit Assert class is used to determine whether a particular test method gives expected results or not. In a test method, we write code to check the business object behavior.

NUnit Features –

• Run test suites parallelly.
• Strong support for data-driven tests.
• Supports multiple platforms including .NET CORE, Compact Framework, and Silverlight.
• Every test case can be added to more than one category, to allow for selective running.
• These Tests can be run from a console runner, within Visual Studio through a Test Adapter, or 3rd party runners.

Attribute difference Test class vs Test fixture

Using the “Test fixture” attribute we can provide parameters for class but using “Test class” will allow parameters for only Test attributes method. 

E.G – [TestFixture(“hello”, “hello”, “goodbye”)]

REST API:-

A RESTful API is used to send HTTP requests like GET, PUT, POST, and DELETE data through existing protocols.

Working Flow of REST Request:-

 After sending a Rest request from the user it will go to API=> App layer=> Controller=> Repository=> Database Services, performs execution and sends a response back to the server.

How to Integrate REST API with Unit testing using NUnit Framework?

Step-1: Download and install Nunit3-console or follow the links given below:-https://github.com/nunit/nunit-console/releases/download/v3.10/NUnit.Console-3.10.0.zip

Step-2: Open the respective Unit testing project in Visual Studio Or Create a new Unit testing project as:

Step-3: Open NuGet Package Manager Console for that project and type following commands in the given order:

• Install-Package NUnit -Version 3.12.0
• Install-Package RestSharp -Version 103.1
• Install-Package NUnit3TestAdapter -Version 3.13.0

       Perform this for each Unit testing project.

Step-4: Performing Nunit we need to declare Test class and Test attribute for function

Step-5: Build and execute the test project

Step-6: There are 2 ways of running Unit test:

1)Through Test Explorer in Visual Studio:

Click on Test tab →  Select Windows tab →  Click on Test Explorer

After this a new pane will open on the left side which will contain all the test cases found by the test explorer. These are the test cases which have attributes [Test] above them in a test fixture in Unit testing projects.

• You can run these test cases selectively or all together.

• You can also debug test cases by right-clicking on them and selecting the Debug option to check the workflow of a particular test case.

The NUnit 3 Test Adapter which we installed earlier, allows you to run NUnit 3 tests inside Visual Studio.

2)Through Command Prompt:

Note: Always Open Command prompt  in administrator mode for running NUnit console command-line test cases

There are 3 ways of Testing:

1. Test by using Default parameters
2. Test by providing parameters 
3. Test by providing invalid parameters

1) Change directory to installation directory of NUnit console

eg: C:\WINDOWS\system32>cd C:\Program Files (x86)\NUnit.org\nunit-console  

2) Sample test case

C:\Program Files (x86)\NUnit.org\nunit-console>nunit3-console.exe 
--testparm:hotelbookingid=AIR
--test:"HotelBooking.DataLayer.Tests.HotelSeriviceTests.GetBookingSystemSettings" 
"E:\PROJECTS\UnitTests\HotelBooking.DataLayer.Tests\bin\Debug\HotelBooking.DataLayer.Tests.dll"

Where,

--test param → parameters to be passed to test case

(If multiple parameters need to be passed following the same syntax for each param with space in between and if no parameters are required then skip this)

--test → namespace of the test case class which contain program filename and test method name

"E:\PROJECTS\UnitTests\HotelBooking.DataLayer.Tests\bin\Debug\HotelBooking.DataLayer.Tests.dll" → DLL path to Unit testing project folder 

If we don’t pass any test parameters, then the tests will run with default parameters given in the code.

Conclusion

 In this article, we explained how to write  Unit tests for Rest API and the purpose was to get an idea about how Unit tests are written and executed and a major advantage of this Unit testing is that we know the actual rest request failed reason. 

Let’s try an exercise. Try to remember any memories about your childhood. Now try to remember the same memory again after some time. You shall be able to remember it much quicker the second time. This happens because as soon as you recalled the memory the first time, your brain saved this information in your recent memory.

Caching works exactly the same way. Cachingenables us to store data in memory for quick access. When the data is needed again, applications can fetch the data from the cache instead of fetching it from the source. In addition, caching can also make data available when the data source is unavailable. Therefore, caching is one of the most popular performance optimization techniques which not only saves time but also increases the overall performance of an application or website.

There are two main areas for implementing caching mechanism

1. Application Caching

2. Website caching

Application cache is used to store and fetch web resources that are fetched from the web server in the first request. Getting resources from the cache is more efficient and faster than getting them from the source. This means it can be loaded instantly as no retrieving is needed and the resource will be ready to use.

In application caching, we can use the SQLDependency Class which establishes a relationship between an item stored in an ASP.NET application’s cache object and either a specific SQL Server database table or the results of a SQL query.

We can initialize dependency like:

SqlDependency = new SqlCacheDependency("DB_Name", "Column_name");

While using this class there is a possibility of

DatabaseNotEnabledForNotificationException

therefore, we need to implement try and catch blocks with the code to handle exceptions.

The CacheDependency class monitors the dependency relationships so that, when any of the dependencies change, the cached item associated with it will be automatically removed. We can implement this class as:

CacheDependency dep = new CacheDependency(fileName, dt);
cache.Insert("key", "value", dep);
if (dep.HasChanged)
{
Response.Write("The dependency has changed and the item will be removed");
}

2. Website caching means the resources from site sources are fetched in the first request and stored in the cache.

There are two main types of caching mechanisms

1. Client-side Caching

When a user visits a site for the first time, the browser stores items like CSS files and images for a specific time. Browser caching allows these saved items to be immediately available upon the next request, rather than placing a new request which needs to be sent back to the server. It will reduce the number of requests and results in faster web page loading time and improves the user experience. Browser caching is useful for reducing download time for static content like CSS, js, and images.

We can also use Local storage which enables us to store data locally in a browser. This data has no expiration date and will persist even after the browser window is closed. The following are some methods for using local storage:

• setItem() — Add key and value to local storage
• getItem() — Retrieve a value by the key
• removeItem() — Remove an item by key
• clear() — Clear all storage

For example, we can use local storage in Javascript like:

localStorage.setItem("key", value);
localStorage.removeItem(“key”);
localStorage.getItem(“key”)
localStorage.clear()

2. Server-Side Caching

This type of caching can serve many visitors from a centralized cache whenever a user visits the website. This helps us to reduce the load on the server and improves web page loading time for users. This type of cache acts on behalf of the web server and serves the users by providing them the required data without hitting app servers and database servers. 

Caching is implemented through “Cache-Control” which is an HTTP header directive which is sent out in every instance of the HTTP response header. Although caching is helpful in many ways but, for security reasons, any sensitive data such as history and user account information should never be cached.

ASP.NET provides the following different types of caching :

Output Caching

Rendering a web page may involve some complex operations like accessing the database and initializing complex controls. Output caching allows us to bypass the round trip to the server, by caching data in the memory. It stores a copy of the completely rendered HTML page or part of the page which is sent to the client from the server. When the client requests for this page next time, instead of fetching the page from the server, the cached copy of the page is used to save time.

Syntax for implementation of Output Cache directive is:

<%@ OutputCache=" " Duration="10" VaryByParam="*" %>

The option VaryByParam helps you to specify the variables that would require a new cache entry. Other possible options include VaryByCustom, VaryByHeader and Location.

Data Caching

Data caching means caching data from a data source. When the cache expires fresh data is obtained from the data source and the cache is refilled.

The main aspect of data caching is caching the data source. These controls are derived from the abstract class DataSourceControl and have the following properties for implementing caching:

• CacheDuration – Sets the number of seconds for which caching will be done
• CacheExpirationPolicy – Defines the cache behavior when the cache has expired.
• EnableCaching – Specifies whether to cache data or not.

Object Caching

Object caching is to cache the objects on a page, such as data-bound controls. The cached data is stored in the server memory. It provides more flexibility than other caching techniques. The object can be of any type – a data type, a web control, a class or database object and any item can be added to the cache by assigning a key name like:

Cache["key"] = item;

REDIS Cache

Redis is an open-source NoSQL, high-speed memory data structure store. It is quick and it resides entirely in the memory with very small performance overhead. It is free for both commercial and non-commercial use under the BSD license.

It maintains data structures such as Sets, hashes, lists, strings with range queries, bitmaps, and geospatial indexes. It also has built-in support for replication, transactions, and also data persistence.

Redis allows the user to store a huge amount of data without the limitation of relational databases. Redis is written in ANSI C.

Redis is a reliable choice if your application requires to store and recover a huge amount of data and if the application is hosted on multiple servers.

The following are the benefits:

• High performance and application caching
• Simple Usage
• Very easy configuration with any application
• Supports lists of data types(hashes, lists, sets, etc)
• It provides Web UI for viewing web content

In order to install Redis, we need Cloud or Dedicated Server. The hardware requirements include 4 core CPU,16GB RAM, 1GBps Network Connection, and 2 storage devices.

Integration of Redis cache using C#.Net

Step 1: We need to download NuGet package StackExchange.Redis which will be our connector to Redis cache

 public class MyRedisConnectorHelper
{
static class Redis
{
static string redisHost = "127.0.0.1";
static int redisPort = 6397;
static string redisPassword = "admin123";
static string redisConnection = string.Format("{0}:{1},password={2}",redisHost, redisPort, redisPassword);
static string connectionString;
connectionString=redisConnection,syncTimeout=30000,connectTimeout=30000,ssl=False,abortConnect=False, allowAdmin=true"; 
static Lazy multiplexer = CreateMultiplexer();
public static ConnectionMultiplexer Connection
{
get
{
multiplexer.Value.PreserveAsyncOrder = false;
return multiplexer.Value;
}
}
private static Lazy CreateMultiplexer()
{
return new Lazy(() => ConnectionMultiplexer.Connect
(connectionString));
}
}
}

Step 2:  We can use the Redis Cache Manager as:

public class RedisCacheManager : ICacheManager, IDisposable
{
private static IDatabase db;
private readonly RetryPolicy _retryPolicy;

public RedisCacheManager(ILogger logger)
{
db = Redis.Connection.GetDatabase();
var retryStrategy = new FixedInterval(4, TimeSpan.FromSeconds(3));
_retryPolicy = new RetryPolicy(retryStrategy);
}

public T Get(string key, ref bool hasValue)
{
var serializedItem = _retryPolicy.ExecuteAction(() => db.StringGet(key));
var item = JsonConvert.DeserializeObject(serializedItem);
if (item == null)
return default(T);
return item;
}
public void Set(string key, object data, int cacheTime)
{
var expiresIn = TimeSpan.FromMinutes(cacheTime);
var serializedItem = JsonConvert.SerializeObject(data);
_retryPolicy.ExecuteAction(() => db.StringSet(key,serializedItem,expiresIn));
}
}

Another caching option we can use is Memcached. It could be preferable when caching small and static data, such as HTML code snippets. Its internal memory management is more efficient in the simplest use cases because it consumes less memory for metadata. Strings are ideal for storing data that is only read, because strings require no processing. String is the only data type supported by Memcached.

Advantages of Redis over Memcached

1. Data Types Supported:

Memcached supports data records of the simple key-value structure. The data types supported by Redis include String, List, Hash, Set, and SortedSet.  

2. Memory Management Scheme

The unique thing about Redis is that all of the data storage is not in memory. Redis may swap out values that are no longer in use. These values are then made persistent into the disk and are erased from the memory. This feature of Redis can maintain much more data than system memory capacity. Memcached has a high memory management efficiency but its major defect is that it causes space waste.

3. Support of data persistence

Redis supports memory data persistence, whereas Memcached does not support the data persistence operation.

Redis with Java application:

To use Redis with Java we need to download the jar named jedis.jar and include it into the classpath.

We also need Jedis which is a client library in Java for implementing a Redis data store. It is small, fast, and fully compatible with Redis 2.8.x and above.

Now we will see how we can use Redis in-memory data store and Jedis client library in a Java application :

Step 1: We need to add maven dependency for Jedis client library like:

<dependency>
<groupId>redis.clients</groupId>
<artifactId>jedis</artifactId>
<version>3.2.0</version>
<type>jar</type>
</dependency>

Step 2: We can write a simple Java application to connect to a Redis server like:

package com.eduonix.redis.example

import redis.clients.jedis.Jedis;
 public class RedisJavaExample {
 public static void main(String[] args) {
//Connect to Redis server using localhost
      Jedis jedis = new Jedis("localhost");
      System.out.println("Connection is successful");
      System.out.println("Getting response: " + jedis.ping());
   }
}

Step 3. Now we will store a value in Redis cache as:

package com.eduonix.redis.example

import redis.clients.jedis.Jedis;

public class RedisCacheExample {

 public static void main(String[] args) {

      Jedis jedis = new Jedis("localhost");

      System.out.println("Connection successful");    

      jedis.set("Test", "Test data 1");

      //Retrieve the value from the cache

      System.out.println("Stored value: "+ jedis.get("Test"));

   }

}

String is the most common value stored in Redis cache and it is stored as a key-value pair.

Conclusion:

We all know that performance is a key factor when it comes to websites for providing the best experience to end-users. Caching helps with the same by acting as a mediator between server and end-user by providing data on demand quickly. There are various caching mechanisms that can be used to speed up websites or applications. Although caching may seem like an afterthought for small applications, it is very crucial for complex applications.

Ever booked any online or offline ticket for movies, events, travel, or purchased anything from the stores?  Ever thought about what the black lines on the ticket are? Those black lines are known as Barcode.

Gave a thought for the next question, why is this really required?

Barcode ticket scanning provides event venues, theatres, or travel authorities with an efficient method of moving crowds through the entrances. This barcode verifies and validates the ticket instantly through a scanner and gives the entry wherever one is heading to. Each ticket or product has a unique barcode.

Let us understand, what is a Barcode Scanner

Barcode scanners record and translate barcodes from the image present on the ticket into alphanumeric digits. The scanner then sends that information to a computer database, either through a wired or wireless connection.

When the ticket is presented for admission, a staff member or event volunteer will scan the barcode through a scanner. A valid barcoded ticket returns a positive (green) response displaying the buyer’s name, the ticket purchased, and bar code ID.

The barcode ticket scanner prevents holders of fraudulently duplicated tickets from gaining admission. When any additional attempts are made to enter the premises with the barcode ticket the scanner displays a warning message that the ticket was “ALREADY SCANNED”. If a customer presents a ticket that is not valid for the event, the scanner displays an “Invalid” message on the scanner app.

Internal structure of a Barcode Scanner and working functionality

The common barcode scanner is made up of a light source, an optical lens, a scanning module, an analog-to-digital conversion circuit, and plastic housing. It uses the photoelectric element to detect.

The optical signal is converted into an electrical signal, which is then converted into a digital signal by an analog-to-digital converter and transmitted to a computer for processing. The converter then converts the digital signal into a computer signal for processing.

While scanning an image, the light source illuminates from the image and the reflected light converges on the scanning module through the lens. The scanning module then converts the light signal into an analog-digital signal. At this time, the analog-to-digital conversion circuit converts the analog voltage into a digital signal and then sends it to the computer.

The color is quantized with the RGB three-color 8, 10, and 12 bits, and the signal is then processed into the above-mentioned bit number of image output. If there is a higher number of digits of quantization, it means that the image can have more level and depth.

Integration of Barcode Scanner in Travel Industry

Ever been to the airport? Stood in long queues of security check-ins, availing boarding pass, and onboarding gates? Though in spite of such long queues how does this verification gets done faster and saves everyone’s time? This is possible because of a barcode available on the travel tickets.

With the use of online booking systems for travel (flights, trains, and buses), travelers can print out their own boarding pass and check-in by showing the code available on the ticket or boarding pass using their smartphone.

When the barcode is scanned by a barcode scanner at the boarding gate, the complete details of the passenger is displayed on a computer screen i.e. Name, Age, Sex, Source, Destination, Photo (if available), PNR, Passport Number (in case of international travel) and many other details. This integration of barcode scanning in the travel industry saves the time of a person to check all the details manually as they are now automatically available on a screen.

This integration of Barcode Scanning functionality also gives ease to the traveler and saves his time in completing all manual verifications and validations. So the traveler can have a smooth onboarding process.

Benefits of a Barcode Scanner

• Integrates into the system: Barcode scanners are essentially keyboards that are connected directly to existing systems; smartphones likely require Bluetooth adapters and/or drivers to connect to the point of sale (POS) system.
• Has few software issues: Barcode scanners don’t get viruses and don’t generally need software updates, nor are they interrupted by texts or calls from other scanners.
• Durability: Barcode scanners are built to last, and can operate for years without any problems.
• Functionality: They can read codes quickly and read the codes from a distance, leaving behind other typical dilemmas of non-readers, like balancing battery life and slow operating systems.

Conclusion:

A barcode reader or scanner is the best option for a business looking to integrate barcode technology into its tracking and auditing system. 

Excited to travel to a destination with your beloved one on a vacation, or to attend some business meetings to crack a million dollars deal, or with some other travel purpose. To have a memorable trip you should be more focused on your destination.

What if you found some magical tool using which you can manage your entire journey like hire a car, book a flight with cozy seats, hotels. Not just it, you can add /delete or change your itinerary as easy as snapping your finger. Here comes a GDS that will help you out with all your travel needs.

Why Apollo GDS ?

Before moving to Apollo GDS, let’s understand the history of Apollo evolution first.

 United Airlines was the airline that came up with  Apollo CRS back in 1971. Almost fifteen years later, Apollo Travel Services became a standalone affiliate of United and was rebranded as Covia™. In 2009, Travelport became a collaboration partner in eNett™, a leading provider of integrated payment solutions for the travel industry.

Travelport combines three GDSs: Apollo, Worldspan, and Galileo. They are all merged into a single Travelport Universal API, the universal API is a package of the following functions:

Expansion (inventory and coverage)

Travelport GDS collects and distributes information across channels on access to airlines, rails, cruises, and hire rental cars. In addition to that, it allows for fetching information from available hotels and tours.

Travelport GDS is the only GDS equally covering all directions and continents. It is evenly represented in the Americas, though to a greater extent in South America, EMEA and the APAC region. In its distribution channel, Travelport combines 650,000 hotel properties, 400+ airline partners, 125 low-cost carriers, car rental units in over 38,000 locations, 50 cruise lines, and 15 railway carriers.

Flights:
Travelport gives access to booking direct flights, connected air and train routes, and ancillary services, such as baggage, meals, and insurance.

Hotels:Apart from basic hotel information and booking, Travelport can offer deals from non-GDS providers: Agoda, Tourico, and others to name a few. It also has support discounts for corporate clients.

Car rentals:
Travelport’s car rental functionality is standards are as follows
search, pricing, images, vehicle details, and cancelation.

Railways:
Travelport is heavily focused on providing combined air and train booking availability, including data on optimal connections with flights, ticketing air-rail as a single ticket, and offering train transfers directly to and from an airport.

API integration

• Air API connect
• Rail API connect
• Travelport rooms
• Fares and ancillaries
• Customer profiles

Travelport offers access to low-cost carriers via a Smartpoint solution. It returns information on branded fares and ancillaries and lists LCCs along with other airlines for quick comparison. The platform is available only for manual booking too via travel agents.

How to Connect to Apollo GDS

• Get IATA or ARC accreditation.
• Pass the GDS terminal training.
• Sign an agreement.
• Negotiate competitive deals.

Defiance of Apollo GDS

While discussing the power of Apollo GDS let’s take a glance at some challenges that we might encounter while using Apollo. Let’s see them one by one

• Option for One Way/Return/Multi-City ( Multi-City search provides an option to select multiple destination cities to search flight and book all flights in a single itinerary)
• Show the list of flights as per the XML Response received from GDS Server based upon search criteria.
• Application of Slice and Dice.
• Show Flight Logo, Flight Name, Flight Number, Segment Information, Departure Details ( City, Date, Time ), Arrival Details (City, Date, Time), Trip Duration, No. Of Stops
• Advance Filter Search
• Show Fare Details like Base Fare, Taxes & Fees, Grand Total Rate
• Show Baggage Information, Penalties Description, Refundable and Non-Refundable details
• Seat Selection Scope

Conclusion

For the last few decades, GDS has provided unparalleled service to airlines because of its property like security, reliability, speed, and accuracy to name a few. If I look at IATA research, what airlines will look in the future are more flexible, robust commerce platforms built on contemporary software and architecture. If GDS evolves to meet the changing needs of the airline industry, it will continue to evolve as it did from the Lazy Susan system of the 1950s, it will survive otherwise it will cease to be relevant.