Top 24 Unit Testing Interview Questions And Answers

Question 1

How to unit test an object with _database_ queries?

Accepted Answer

* If your objects are tightly coupled to your data layer, it is difficult to do proper unit testing. Your objects should be _persistent ignorant_. You should have a _data access layer_, that you would make requests to, that would return objects. 
* Then _mock_ out your calls to the database. This way, you can leave that DB dependants part out of your unit tests, test them in isolation or write _integration tests_.

Question 2

What is the difference between _Unit Tests_ and _Functional Tests_?

Accepted Answer

* **Unit Test** - testing an individual unit, such as a method (function) in a class, with all dependencies mocked up.
* **Functional Test** - AKA Integration Test, testing a slice of functionality in a system. This will test many methods and may interact with dependencies like Databases or Web Services.

Question 3

What is _Mocking_?

Accepted Answer

**Mocking** is primarily used in unit testing. An object under test may have dependencies on other (complex) objects. To isolate the behavior of the object you want to replace the other objects by mocks that simulate the behavior of the real objects. This is useful if the real objects are impractical to incorporate into the unit test.

In short, **mocking **is creating objects that simulate the behavior of real objects.

Question 4

Should unit tests be written for _Getter_ and _Setters_?

Accepted Answer

Properties (getters/setters) are good examples of code that usually doesn’t contain any logic, and doesn’t require testing. But watch out: once you add any check inside the property, you’ll want to make sure that logic is being tested.

In other words, if your getters and setters do more than just get and set (i.e. they're properly complex methods), then yes, they should be tested. But don't write a unit test case just to test a getter or setters, that's a waste of time.

Question 5

What's the difference between _Mock_ an object or _Spy_ on it?

Accepted Answer

* **Mock object** replace mocked class entirely, returning recorded or default values. You can create a mock out of _thin air_. This is what is mostly used during unit testing.
* When **spying**, you take an existing object and _replace_ only some methods. This is useful when you have a huge class and only want to _mock_ certain methods (_partial mocking_). We _spy_ real objects meaning that we can instruct which method to be _stubbed_. In a nutshell, you will _spy_ **real object** and _stub_ **some of the methods**.

When in doubt, use mocks.

Question 6

How can I unit test a _GUI_?

Accepted Answer

The answer is to use MVC and move as much logic out of the GUI as possible. For the graphic, you should test the value that you supply to the code that generates the graphic.

I heard from a coworker a long time ago that when SGI was porting OpenGL to new hardware, they had a bunch of unit tests that would draw a set of primatives to the screen and then compute an MD5 sum of the frame buffer. This value could then be compared to known good hash values to quickly determine if the API is per pixel-accurate.

Question 7

Can you provide and example of a common _Mocking_ scenario?

Accepted Answer

**Mocks** are basically objects that look like the object you are trying to call a method on, in the sense that they have the same properties, methods, etc. available to the caller. But instead of performing whatever action they are programmed to do when a particular method is called, it skips that altogether and just returns a result. That result is typically defined by you ahead of time.

Let look at the mocking out your calls to the database. In order to set up your objects for mocking, you probably need to use some sort of _inversion of control/ dependency injection pattern_, as in the following pseudo-code:

```php
class Bar
{
    private FooDataProvider _dataProvider;

public instantiate(FooDataProvider dataProvider) {
        _dataProvider = dataProvider;
    }

public getAllFoos() {
        // instead of calling Foo.GetAll() here, we are introducing an extra layer of abstraction
        return _dataProvider.GetAllFoos();
    }
}

class FooDataProvider
{
    public Foo[] GetAllFoos() {
        return Foo.GetAll();
    }
}
```

Now in your unit test, you create a mock of `FooDataProvider`, which allows you to call the method `GetAllFoos` _without having to actually hit the database_.

```php
class BarTests
{
    public TestGetAllFoos() {
        // here we set up our mock FooDataProvider
        mockRepository = MockingFramework.new()
        mockFooDataProvider = mockRepository.CreateMockOfType(FooDataProvider);

// create a new array of Foo objects
        testFooArray = new Foo[] {Foo.new(), Foo.new(), Foo.new()}

// the next statement will cause testFooArray to be returned every time we call FooDAtaProvider.GetAllFoos,
        // instead of calling to the database and returning whatever is in there
        // ExpectCallTo and Returns are methods provided by our imaginary mocking framework
        ExpectCallTo(mockFooDataProvider.GetAllFoos).Returns(testFooArray)

// now begins our actual unit test
        testBar = new Bar(mockFooDataProvider)
        baz = testBar.GetAllFoos()

// baz should now equal the testFooArray object we created earlier
        Assert.AreEqual(3, baz.length)
    }
}
```

Question 8

Is writing Unit Tests worth it for already exciting functionality?

Accepted Answer

It's absolutely worth it. Our app has complex cross-validation rules, and we recently had to make significant changes to the business rules. We ended up with conflicts that prevented the user from saving. I realized it would take forever to sort it out in the application (it takes several minutes just to get to the point where the problems were). I'd wanted to introduce automated unit tests and had the framework installed, but I hadn't done anything beyond a couple of dummy tests to make sure things were working. With the new business rules in hand, I started writing tests. _The tests quickly identified the conditions that caused the conflicts, and we were able to get the rules clarified._

If you write tests that cover the functionality you're adding or modifying, you'll get an immediate benefit. If you wait for a re-write, you may never have automated tests.

You shouldn't spend a lot of time writing tests for existing things that already work. Most of the time, you don't have a specification for the existing code, so the main thing you're testing is your reverse-engineering ability. On the other hand, if you're going to modify something, you need to cover that functionality with tests so you'll know you made the changes correctly. And of course, for new functionality, write tests that fail, then implement the missing functionality.

Question 9

_When_ and _where_ should I use _Mocking_?

Accepted Answer

Rule of thumb:

If the function you are testing needs a complicated object as a parameter, and it would be a pain to simply instantiate this object (if, for example, it tries to establish a TCP connection), use a **mock**. Mock objects allow you to set up test scenarios without bringing to bear large, unwieldy resources such as databases. Mock objects are simulated objects that mimic the behaviour of real objects in controlled ways.

Typically you write a mock object if:

- The real object is too complex to incorporate it in a unit testing (For example a networking communication, you can have a mock object that simulate been the other peer)
- The result of your object is non-deterministic
- The real object is not yet available

**For example:**
 
Let's say we want to test that method `sendInvitations(MailServer mailServer)` calls `MailServer.createMessage()` exactly once, and also calls `MailServer.sendMessage(m)` exactly once, and no other methods are called on the `MailServer` interface. This is when we can use mock objects.

With mock objects, instead of passing a real `MailServerImpl`, or a test `TestMailServer`, we can pass a mock implementation of the `MailServer` interface. Before we pass a mock `MailServer`, we _train_ it, so that it knows what method calls to expect and what return values to return. In the end, the mock object asserts, that all expected methods were called as expected.

Note:

A Unit Test should test a single code path through a single method. When the execution of a method passes outside of that method, into another object, and back again, you have a dependency.

When you test that code path with the actual dependency, you are not unit testing; you are integration testing. While that's good and necessary, it isn't unit testing.

Question 10

How would you unit test _private_ methods?

Accepted Answer

If you want to unit test a private method, something may be wrong. Unit tests are (generally speaking) meant to test the interface of a class, meaning its public (and protected) methods. You can of course "hack" a solution to this (even if just by making the methods public), but you may also want to consider:

1. If the method you'd like to test is really worth testing, it may be worth to move it into its own class.
 2. Add more tests to the public methods that call the private method, testing the private method's functionality. (As the commentators indicated, you should only do this if these private methods's functionality is really a part in with the public interface. If they actually perform functions that are hidden from the user (i.e. the unit test), this is probably bad).

Top 24 Unit Testing Interview Questions

How to unit test an object with database queries?

What is the difference between Unit Tests and Functional Tests?

What is Mocking?

Should unit tests be written for Getter and Setters?

What's the difference between Mock an object or Spy on it?

What do I lose by adopting TDD? What are the disadvantages of Test Driven Development?

Should I Unit Test private methods or only public ones?

What is the fundamental value of Unit Tests vs Integration Tests?

What's the difference between Unit Tests and Integration Tests?

Name some Unit Testing benefits for devs that you personally experienced

When and where should I use Mocking?

How would you unit test private methods?

How can I unit test a GUI?

Is writing Unit Tests worth it for already exciting functionality?

What is a reasonable Code Coverage `%` for unit tests (and why)?

Can Unit Testing be successfully added into an existing production project? If so, how and is it worth it?

Explain what is `Arrange-Act-Assert` pattern?

What are best practices for Unit Testing methods that use cache heavily?

What's the best strategy for Unit-Testing database-driven applications?

What is Unit test, Integration Test, Smoke test, Regression Test and what are the differences between them?

What is the best way to unit test a method that doesn't return anything (`void`)?

How do I test a `private` function or a class that has `private` methods, fields or inner classes?

Is Unit Testing worth the effort?

Can you provide and example of a common Mocking scenario?

Top 24 Unit Testing Interview Questions

How to unit test an object with database queries?

What is the difference between Unit Tests and Functional Tests?

What is Mocking?

Should unit tests be written for Getter and Setters?

What's the difference between Mock an object or Spy on it?

What do I lose by adopting TDD? What are the disadvantages of Test Driven Development?

Should I Unit Test private methods or only public ones?

What is the fundamental value of Unit Tests vs Integration Tests?

What's the difference between Unit Tests and Integration Tests?

Name some Unit Testing benefits for devs that you personally experienced

When and where should I use Mocking?

How would you unit test private methods?

How can I unit test a GUI?

Is writing Unit Tests worth it for already exciting functionality?

What is a reasonable Code Coverage % for unit tests (and why)?

Can Unit Testing be successfully added into an existing production project? If so, how and is it worth it?

Explain what is Arrange-Act-Assert pattern?

What are best practices for Unit Testing methods that use cache heavily?

What's the best strategy for Unit-Testing database-driven applications?

What is Unit test, Integration Test, Smoke test, Regression Test and what are the differences between them?

What is the best way to unit test a method that doesn't return anything (void)?

How do I test a private function or a class that has private methods, fields or inner classes?

Is Unit Testing worth the effort?

Can you provide and example of a common Mocking scenario?

What is a reasonable Code Coverage `%` for unit tests (and why)?

Explain what is `Arrange-Act-Assert` pattern?

What is the best way to unit test a method that doesn't return anything (`void`)?

How do I test a `private` function or a class that has `private` methods, fields or inner classes?