C++: Separating object's creation from use (for testing purposes)

Question

Suppose I have code like below. http_client is an external dependency (a 3rd party API) I don't have control over. transaction_handler is a class I control and would like to write unit tests for.

// 3rd party
class http_client
{
public:
    std::string get(std::string url)
    {
        // makes an HTTP request and returns response content as string
        // throws if status code is not 200
    }
};

//code to be tested
enum class transaction_kind { sell, buy };
enum class status { ok, error };

class transaction_handler
{
private:
    http_client client;
public:
    status issue_transaction(transaction_kind action)
    {
        try
        {
            auto response = 
                client.get(std::string("http://fake.uri/") + 
                   (action == transaction_kind::buy ? "buy" : "sell"));
            return response == "OK" ? status::ok : status::error;
        }
        catch (const std::exception &)
        {
            return status::error;
        }
    }
};

Because http_client makes network calls I would like to be able to substitute it in my tests with a mock implementation which cuts off the network and allows for testing different conditions (ok/error/exception). Because transaction_handler is supposed to be internal I can modify it to make it testable but I wouldn't want to go over the border (i.e. I would like to avoid pointers or dynamic polymorphism if possible). Ideally I would like to use a kind of dependency injection where my tests would inject a mock http_client. I don't think I can/want to use a 'poor man's DI' where I would create an http_client implementation in the caller and pass it to the transaction_handler (by const reference? std::shared_ptr?) - because I don't control the http_client I would have to come up with an interface and -in the product code - I would have to wrap the http_client in a wrapper class that implements this interface and forwards the calls to the actual/wrapped http_client instance. In the test code I would create a mock implementation of that interface. The interface would have to be a pure abstract method which entails using runtime polymorphism which I wanted to avoid. Another option is to use templates. If I changed the transaction_handler class to look as follows:

template <typename T = http_client>
class transaction_handler
{
private:
    T client;
public:

    transaction_handler(const std::function<T()> &create) : client(create())
    {}

    status issue_transaction(transaction_kind action)
    {
        // same as above, omitted for brevity
    }    
}

I could now create a mock http_client class:

class http_client_mock
{
public:
    std::string get(std::string url)
    {
        return std::string("OK");
    }
};

and create the transaction_class object in my tests like this:

transaction_handler<http_client_mock> t(
    []() -> http_client_mock { return http_client_mock(); });

while I could use the following in my product code:

transaction_handler<> t1(
    []() -> http_client { return http_client(); });

While it seems to work and fullfill most of my requirements (even though I don't like the fact that the code instantiating transaction_handler need to be aware of the http_client type - maybe it can be somehow hidden as a factory class) - does it make sense at all? Or may be there are better ways of doing this kind of things? I spent a considerable amount of time looking for some simple DI patterns to make unit testing easier bud had hard time finding something that would suit my needs. Also, my background is mostly C so maybe I approach the problem from a wrong angle?

Answer 1

I think it's a good idea to mock it. Since http_client is an external dependency, I chose Typemock Isolator++ to handle with it. Look at the code below:

TEST_METHOD(FakeHttpClient) 
{
    //Arrange
    string okStr = "OK";
    http_client* mock_client = FAKE_ALL<http_client>();
    WHEN_CALLED(mock_client->get(ANY_VAL(std::string))).Return(&okStr);

    //Act
    transaction_handler my_handler;
    status result = my_handler.issue_transaction(transaction_kind::buy);

    //Assert
    Assert::AreEqual((int)status::ok, (int)result);
}

Method FAKE_ALL<> allows me to set the behavior of all http_client instances, so no injection needed. Simple API, the code looks accurate, and you don't need to change the production code.

Hope it helps!

Answer 2

I'm maintaining a DI library, and your case is really interesting for me.

Mocking is about dynamic polymorphism or compile time mocking (at least when using C++). You pay 1 indirection to obtain ability to inject what you want (dependence only on 1 interface).

If you want to make code testable, the best way is using interfaces (pure virtual classes in C++ wich does not have interfaces) and inject dependencies only through constructor.

If you really want to avoid polymorphism (or you can't because of external API) you could still accept to have some code that is not fully testable.

---

Conventional way of doing things:

class ConcreteHttpClient : public virtual AbstractHttpClient { /*...*/}

class MockHttpClient : public virtual AbstractHttpClient{ /*...*/ }

You just choose what to inject based on needs ( I intentionally use "new" instead of showing some DI framwork at work).

Production code.

new TransactionHandler ( static_cast< AbstractService>( ConcreteService));

Unit testing the transaction handler

new TransactionHandler ( static_cast< AbstractService>( MockService));

If you later need to test some class using the transaction handler and the transaction handler implements a interface

class TransactionHandler: public virtual AbstractTransactionHandler { /*...*/}

You have just to create a TransactionHandlerMock inheriting from AbstractTransactionHandler

When you use interfaces the advantage is that you can use a Dependency Injection framework to avoid poor man's injection.

---

Compile time mocking.

What you proposed is a viable alternative, basically you assume a "static polymorphism" thanks to templates

Production code:

template <typename T = http_client>
class transaction_handler{/*...*/};

new transaction_handler( /*...*/ );

Unit test code:

using transaction_handler_mocked = transaction_handler< http_client_mock>;

new transaction_handler_mocked( /*...*/ );

However this has few Issues:

• You are depending on "transaction_handler" type on each part of your production code so if you change it you have to recompile every file depending on it.
• You can't inject a mocked handler as a mock itself, unless you change all classes depending on it to become templates accepting the handler.
• Point number 2 means that basically in a complex project you have each class depending on each other, increasin compile times and forcing to whole recompiles of your project just for little changes
• You are not using a Interface (pure virtual class) that means that you can still accidentally access fields or members of template parameters that were not intended to be accessed making your debuggin harder.

---

Other alternatives

• Provide mock at link time, you don't have to mock a whole 3rd party library. Just the classes you are testing. Most IDEs are not thinked to work that way, but probably you can work around with some bash script or custom makefile. (In example, I do that for testing code dependent on C functions, in particular OpenGL)

• Wrap interesting functionalities of libraries you want to test behind a class implementing a pure virtual class (don't know why you want to avoid it). You have good chances that you don't need to wrap all methods and you'll end with a smaller API to test against (just wrap parts you need to use, don't start up front wrapping the whole library)

Use a mocking framework, and possibly a dependency Injection framework.

Answer 3

Just write test routines that match whichever exports of http_client you're using. You're source will be linked in preference to any lib.