Senior Software Test Analyst

STLC (Software Testing Life Cycle) is a fundamental part of SDLC which is used to test software and ensure that the
quality standards are met. It generally involves both verification activities and validation activities. In this, different
activities are executed in a specific order throughout the software testing process. There are basically six different
phases in STLC. They are as follows :

1) Requirement Analysis
2) Test Planning
3) Test Case Development
4) Test Environment Setup
5) Test Execution
6) Test Cycle Closure

Agile testing is basically a software testing process that uses agile methodologies i.e., follow test-first design
paradigm. It evaluates the software from the customer's point of view. It does not require any development team to
complete coding for starting QA, instead of testing and coding can go hand in hand. Features are tested as they are
developed. Some of its advantages include :

1) Boosts the performance as it allows all the testers and developers to work together
2) Features are tested as they are developed
3) Ensure successful delivery of the high-grade product
4) Saves time and money
5) Flexible and highly adaptable to changes
6) Improves product quality and allows developers to release software as early as possible

1) In black-box testing, the tester views the software as a black box, ignoring all the internal structure and behavior.
Their only concern is the input provided to the system and the generated output.

2) Black-box testing verifies the program’s behavior against the specified requirements.

3) During black-box testing, the test conditions are created based upon the software’s functionality but are unaware of
how the software works internally.

4) The software is tested from the end user’s perspective and gives a broader picture of the whole system.

5) Given that the users are only concerned with whether the software works according to their needs and don’t care
how it works, black-box testing helps test software usability and anticipate how the customer will use the product.

1) API testing ensures that the APIs that the software is using work as expected.

2) The tester writes code that makes an API request to the server that provides the API, provides the required inputs,
collects the output from the response, and matches the actual output with the expected output.

3) API testing primarily concerns the business logic of the software that’s exposing the API. It does not involve the
look and feel, accessibility, or usability of the software.

4) API testing can be automated to make it repeatable and reproducible each time they run.

Here are some of the best practices a software development and the testing team should use to ensure quality
software.

1) Decide what to automate
i) It’s not possible or practical to automate certain tests, such as usability, accessibility, exploratory testing, or non-
repetitive test cases that frequently change.


2) Assign test cases based on skill and experience
i) When dividing test cases, take into account the skills and experience of the tester and the complexity and severity
of the feature under test.


3) Removing Uncertainty
i) The whole goal of test automation is to have reliable, accurate, consistent tests that provide helpful feedback to the
tester. If the tests fail due to bugs in the test itself, or it’s giving false positives, then the ROI on test automation starts
decreasing.


4) Choosing the right frameworks and tools
i) There are a lot of tools to perform automation testing. Picking the wrong tool for the test at hand will waste time and
provide false confidence to release software that may fail in production.


5) Keeping test records in a bug database
i) Using a bug database is a best practice whether a team uses test automation or not.
ii) Whenever new bugs are found by the automation tool or by the testers, they should be recorded in a bug tracking
tool with the exact steps to reproduce the bugs and other details.

Similar to a software development and software testing life cycle, automation testing has its life cycle. Here are the
major phases that an automation testing project goes through.

1) Figure out the scope of automation testing
2) Choose the correct automation frameworks and tools
3) Design a test plan + test execution strategy
4) Set up the test environment
5) Development and execution of the test cases
6) Analysis and generation of test reports

Protractor is an open-source automated testing framework that allows you to perform end-to-end testing of your web
applications. It’s built on top of WebDriverJS. Protractor is developed by Google and is especially used for testing
Angular applications.

Protractor runs the tests against the web application by running it in real web browsers. It also interacts with the
application like an end-user would, e.g. clicking buttons, links, filling forms, etc., and verifying the result with the
expected outcome.

Since Protractor is based on the Selenium WebDriver, it’s easy to perform cross-browser testing. It provides a simple
API compared to Selenium, so the learning curve is not too steep. Developers can quickly get familiar with it and start
writing the end-to-end UI tests. You can also take snapshots and compare them using Protractor. It also allows you to
run parallel test cases on different machines.

Here are some of the features to look for when selecting an automation tool : 

i) Test Environment support,
ii) Ease of use,
iii) Debugging features,
iv) Testing capabilities for various elements,
v) UI element identification features,
vi) Should allow database testing.,
vii) Should support multiple frameworks.

1) PUT method is called when you have to modify a single resource while POST method is called when you have to
add a child resource.

2) PUT method response can be cached but you cannot cache POST method responses.

3) You can use UPDATE query in PUT whereas you can use create query in POST.

4) In PUT method, the client decides which URI resource should have, and in POST method, the server decides
which URI resource should have.

5) PUT works as specific while POST work as abstract.

6) If you send the same PUT request multiple times, the result will remain the same but if you send the same POST
request multiple times, you will receive different results.

7) PUT method is idempotent whereas POST method is not idempotent.

Triggers in SQL is kind of stored procedures used to create a response to a specific action performed on the table
such as INSERT, UPDATE or DELETE. You can invoke triggers explicitly on the table in the database.

Action and Event are two main components of SQL triggers. When certain actions are performed, the event occurs in
response to that action.

Syntax :

CREATE TRIGGER name {BEFORE|AFTER} (event [OR..]}
ON table_name [FOR [EACH] {ROW|STATEMENT}]
EXECUTE PROCEDURE functionname {arguments}

SQL GRANT and REVOKE commands are used to implement privileges in SQL multiple user environments. The
administrator of the database can grant or revoke privileges to or from users of database objects by using commands
like SELECT, INSERT, UPDATE, DELETE, ALL, etc.

1) GRANT Command : This command is used to provide database access to users other than the administrator.

Syntax:

GRANT privilege_name
ON object_name
TO {user_name|PUBLIC|role_name}
[WITH GRANT OPTION];
In the above syntax, the GRANT option indicates that the user can grant access to another user too.


2) REVOKE command : This command is used to provide database deny or remove access to database objects.

Syntax:

REVOKE privilege_name
ON object_name
FROM {user_name|PUBLIC|role_name};

The differences between Abstract Class and Interface are as follows :

Abstract Class :

1) Abstract classes have a default constructor and it is called whenever the concrete subclass is instantiated.
2) It contains Abstract methods as well as Non-Abstract methods.
3) The class which extends the Abstract class shouldn’t require the implementation of all the methods, only Abstract
methods need to be implemented in the concrete sub-class.
4) Abstract class contains instance variables.


Interface :

1 )It doesn’t have any constructor and couldn’t be instantiated.
2) The abstract method alone should be declared.
3) Classes that implement the interface should provide the implementation for all the methods.
4) The interface contains only constants.

1) Garbage Collection in Java is a process by which the programs perform memory management automatically.

2) The Garbage Collector(GC) finds the unused objects and deletes them to reclaim the memory. I

3) In Java, dynamic memory allocation of objects is achieved using the new operator that uses some memory and the
memory remains allocated until there are references for the use of the object.

4) When there are no references to an object, it is assumed to be no longer needed, and the memory, occupied by
the object can be reclaimed.

5) There is no explicit need to destroy an object as Java handles the de-allocation automatically.
The technique that accomplishes this is known as Garbage Collection. Programs that do not de-allocate memory can
eventually crash when there is no memory left in the system to allocate. These programs are said to have memory
leaks.


Garbage collection in Java happens automatically during the lifetime of the program, eliminating the need to de-
allocate memory and thereby avoiding memory leaks.

In C language, it is the programmer’s responsibility to de-allocate memory allocated dynamically using free()
function.This is where Java memory management leads.

No one wants its software to fail or crash. Exceptions are the major reason for software failure. The exceptions can
be handled in the program beforehand and prevent the execution from stopping. This is known as exception handling.
So exception handling is the mechanism for identifying the undesirable states that the program can reach and
specifying the desirable outcomes of such states.
Try-catch is the most common method used for handling exceptions in the program.

1) Storage area : In string, the String pool serves as the storage area. For StringBuilder and StringBuffer, heap
memory is the storage area.

2) Mutability : A String is immutable, whereas both the StringBuilder and StringBuffer are mutable.

3) Efficiency : It is quite slow to work with a String. However, StringBuilder is the fastest in performing operations. The
speed of a StringBuffer is more than a String and less than a StringBuilder. (For example appending a character is
fastest in StringBuilder and very slow in String because a new memory is required for the new String with appended
character.)

4) Thread-safe : In the case of a threaded environment, StringBuilder and StringBuffer are used whereas a String is
not used. However, StringBuilder is suitable for an environment with a single thread, and a StringBuffer is suitable for
multiple threads.

In Java, the final keyword is used as defining something as constant /final and represents the non-access modifier.

1) final variable :
i) When a variable is declared as final in Java, the value can’t be modified once it has been assigned.
ii) If any value has not been assigned to that variable, then it can be assigned only by the constructor of the class.


2) final method :
i) A method declared as final cannot be overridden by its children's classes.
ii) A constructor cannot be marked as final because whenever a class is inherited, the constructors are not inherited.
Hence, marking it final doesn't make sense. Java throws compilation error saying - modifier final not allowed here


3) final class :
i) No classes can be inherited from the class declared as final. But that final class can extend other classes for its
usage.

JVM is platform dependent because it takes java byte code and generates byte code for the current operating
system. So Java software is platform dependent but Java language is platform independent because different
operating system have different JVMs.

Set : 
1) It is an unordered sequence.
2) Duplicate elements are not permitted in Set.
3) Access to items from a certain position is not permitted.
4) A null element can only be stored once.


List : 
1) It is an ordered sequence.
2) Duplicate elements are allowed in the list.
3) Elements can be accessed based on their position.
4) It is possible to store several null elements.

Hash Set :
1) It implements the Set Interface.
2) It does not allow duplicate values.
3) While adding an element it requires only one object as a parameter.
4) Internally, HashSet uses HashMap to add entries. The key K in a HashSet is the argument supplied in the
add(Object) method. For each value supplied in the add(Object) method, Java assigns a dummy value.
5) It is slower than HashMap.



Hash Map :
1) It implements the Map Interface.
2) The key needs to be unique while two different keys can have the same value.
3) While adding an entry, it requires two object values, the Key and the Value as the parameter.
4) There is no concept of duplicate values.
5) It is faster than HashSet.

Tip 1 : The cross questioning can go intense some time, think before you speak.

Tip 2 : Be open minded and answer whatever you are thinking, in these rounds I feel it is important to have opinion.

Tip 3 : Context of questions can be switched, pay attention to the details. It is okay to ask questions in these round,
like what are the projects currently the company is investing, which team you are mentoring. How all is the work
environment etc.

Tip 4 : Since everybody in the interview panel is from tech background, here too you can expect some technical
questions. No coding in most of the cases but some discussions over the design can surely happen.

If you get this question, it's an opportunity to choose the most compelling information to share that is not obvious from
your resume.

Example :

Strength -> I believe that my greatest strength is the ability to solve problems quickly and efficiently, which makes me
unique from others.

Ability to handle Pressure -> I enjoy working under pressure because I believe it helps me grow and become more
efficient.


Tip : Emphasize why you were inspired to apply for the job. You can also explain that you are willing to invest a great
deal of energy if hired.

These are generally very open ended questions and are asked to test how quick wit a candidate is. So there is
nothing to worry about if you have a good command over your communication skills and you are able to propagate
your thoughts well to the interviewer.