Senior Software Engineer

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

Test driver and test stub, both are types of test harness that are used to provide a simulation environment for testing
a module or component. They both are dummy modules specially created for test purposes.

Test stubs: Test stubs are used in a top-down testing approach and allow testing of the upper levels of the code when
the lower levels of the code are not developed yet. It is used as ‘called programs’ when subprograms are under
construction.

Test drivers: Test drivers are used in a bottom-up testing approach and allow testing of the lower levels of the code
when the upper levels of the code are not developed yet. It is used as ‘called programs’ when main programs are
under construction.

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

Though it varies depending on the size and structure of the software development teams, typically, a bug can be assigned the following types of severities, going from low to high : 

1) Low
i) User Interface bugs
ii) Accessibility issues


2) Medium
i) Leaky abstractions
ii) Software hangs
iii) Users unable to perform a specific action
iv) Boundary conditions


3) High
i) Crashing under high load
ii) Business logic and/or calculation errors
iii) Any user action that causes the software to crash
iv) Exposing sensitive user data
v) Security problems
vi) Loss of data

Bug :
Sometimes most people are confused between defect and bug, they say that bug is the informal name of defect. Actually bugs are faults in system or application which impact on software functionality and performance. Usually bugs are found in unit testing by testers.

There are different types of bugs, some of them are given below.

1) Functional Errors
2) Compilation Errors
3) Missing commands
4) Run time Errors
5) Logical errors
6) Inappropriate error handling

Above given these errors lead to bug



Defect : 
Defect is defined as the deviation from the actual and expected result of application or software or in other words, defects are defined as any deviation or irregularity from the specifications mentioned in the product functional specification document. Defect is also solved by the developer in development phase or stage.

Reasons for Defects : 

1) Any deviation from the customer requirements is called as defect.
2) By giving wrong input may lead to defect.
3) Any error in logic code may lead to defect.

All web applications run in browsers such as Google Chrome, Mozilla Firefox, Internet Explorer, Safari, etc. Though they all work primarily the same in implementing the web standards, there are subtle differences in all of them. When building the software, it’s not always possible for the software developer to meticulously test the feature on multiple browsers, noticing the subtle inconsistencies.

1) In cross-browser testing, a software tester launches the web application in all the supported browsers and tries to test the same functionality on all of them. 

2) They note any unexpected behavior in a browser that doesn’t work as expected or looks different; note the behavior and the browser name and version in the test report. 

3) This helps the programmer to fix the behavior in all the browsers where it doesn't work as intended.

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.

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.

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

It’s not possible to automate the testing of CAPTCHA. That is the goal behind any good CAPTCHA strategy. By definition, a computer can’t automate it. If it could, then it’s not a good challenge that you can use in your application.

However, if you need to test an application that uses CAPTCHA, you have to work with the development team to build a workaround or a back door that allows the automated test to bypass the CAPTCHA challenge. It’s important to restrict this workaround only in the test environment and not release it to production.

The JUnits annotation linked with Selenium are :

1) @Before public void method() – It will perform the method () before each test, this method can prepare the test
2) @Test public void method() – Annotations @Test identifies that this method is a test method environment
3) @After public void method() - To execute a method before this annotation is used, test method must start with
test@Before

The language used for writing test scripts in Selenium IDE is called Selenese. It is a set of commands used to test your web application or system. Selenium commands could be divided into 3 major categories : 

1) Actions: These are the commands interacting directly with web applications.
2) Accessors: These are the commands which allow users to store values to a user-defined variable.
3) Assertions: They enable a comparison of the current state of the application with its expected state.

Selenium has the support of majorly 4 navigation commands:

1) navigate().back(): This command is used for taking the user to the last webpage of the browser history.

2) navigate().forward(): This command is used for taking the user to the next web page of the browser history.

3) navigate().refresh(): This command is used for reloading the web components of a webpage by refreshing it.

4) navigate().to(): This command is used for navigating to a particular URL in a new web browser. It takes the URL to be migrated to, as a parameter.

Open-source testing tools, Selenium and Cucumber are both used for functional testing. However, there are some
distinctions between them.

Here are some key distinctions between Selenium and Cucumber :

1) Cucumber is a behavior-driven development automation tool that may be used with Selenium. Selenium is a web
browser automation tool for web projects (or Appium).

2) Cucumber is used for acceptance testing, while Selenium is used for automated UI testing.

3) Technical teams (SDETs/programmers) favour Selenium, while non-technical teams often choose Cucumber
(business stakeholders and testers).

4) Cucumber isn't required for Selenium to work. Cucumber's step-definition implementation is based on Selenium or
Appium.

5) The script creation with Selenium is complicated, whereas Cucumber is straightforward.

An annotation is a type of text that has been pre-defined and has a specified meaning. It tells the compiler/interpreter
what to do when the program runs. The annotations on Cucumber are as follows : 

1) Given : It specifies the requirements for running the test.
Example : Given I have an account on Interviewbit.

2) When : It establishes the starting point for any test scenario.
Example : When I log in to Interviewbit.

3) Then : It contains the expected result of the test which is to be executed.
Example : Then registration should be successful.

4) And : Between any two statements, it gives the logical AND condition. AND can be combined with the GIVEN,
WHEN, and THEN statements.
Example : When I enter my account number AND CVV.

5) But : It denotes a logical OR relationship between two propositions. OR can be combined with the GIVEN, WHEN,
and THEN statements.
Example : Then I should be logged in BUT I must enter the OTP.

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.

Tip : For an experienced professional seeking a change, this is a common question. The easiest method to respond
to this question is to state that you are leaving your current work in order to advance your career. Make sure you don't
criticize or speak poorly about the company where you now work.