模拟具体类：模板并避免条件编译

Question

我正在尝试测试具有这种结构的具体对象。

class Database {
 public:
  Database(Server server) : server_(server) {}
  int Query(const char* expression) {
    server_.Connect();
    return server_.ExecuteQuery();
  }

 private:
  Server server_;
};

即它没有虚函数，更不用说定义良好的接口了。

我想要一个调用模拟服务进行测试的假数据库。更糟糕的是，我希望针对真实版本或假版本构建相同的代码，以便相同的测试代码可以：

• 测试真实的数据库实现 - 用于集成测试
• 测试假实现，这调用模拟服务

为了解决这个问题，我使用了一个模板化的假数据库，如下所示：

#ifndef INTEGRATION_TESTS
class FakeDatabase {
 public:
  FakeDatabase() : realDb_(mockServer_) {}
  int Query(const char* expression) {
    MOCK_EXPECT_CALL(mockServer_, Query, 3);
    return realDb_.Query();
  }
private:
  // in non-INTEGRATION_TESTS builds, Server is a mock Server with
  // extra testing methods that allows mocking
  Server mockServer_;
  Database realDb_;
};
#endif

template <class T>
class TestDatabaseContainer {
 public:
  int Query(const char* expression) {
    int result = database_.Query(expression);
    std::cout << "LOG: " << result << endl;
    return result; 
  }
private:
  T database_;
};

编辑： 请注意，假数据库必须调用真实数据库（但使用模拟服务器）。

现在，为了在它们之间进行切换，我计划使用以下测试框架：

class DatabaseTests {
 public:
#ifdef INTEGRATION_TESTS
  typedef TestDatabaseContainer<Database> TestDatabase ;
#else
  typedef TestDatabaseContainer<FakeDatabase> TestDatabase ;
#endif

  TestDatabase& GetDb() { return _testDatabase; }

 private: 
  TestDatabase _testDatabase;
};

class QueryTestCase : public DatabaseTests {
 public:
  void TestStep1() {
    ASSERT(GetDb().Query(static_cast<const char *>("")) == 3);
    return;
  }
};

我不太喜欢在真假之间进行编译时切换。

所以，我的问题是：

1. 是否有更好的方法在数据库和 FakeDatabase 之间切换？例如，是否可以在运行时以干净的方式完成此操作？我喜欢避免#ifdefs。
2. 另外，如果有人有更好的方法来制作模仿具体课程的假课程，我将不胜感激。

我不想在实际测试代码（QueryTestCase 类）中使用模板化代码。

也可以随意批评代码风格本身。您可以在键盘上看到此代码的编译版本。

Answer 1

免责声明 我在 Typemock 工作。

在以下示例中，代码是根据真实版本构建的，生产代码没有任何更改。

正在测试：

class Server
{
    public:
    void Connect(){/* real implementation*/}
    int ExecuteQuery() { return 0; // real implementation }
};

class Database{

    public:
    Database(Server server) : server_(server) {}

    int Query(const char* expression) {
           server_.Connect();
           return server_.ExecuteQuery();
    }

    private:
           Server server_;
};

测试类：

TEST_CLASS(GlobalCMethods)
{
public:

测试真实的数据库实现 - 用于集成测试：
测试真实的数据库实现意味着像在真实代码中一样使用它。下面的例子就是这样做的。但是，您可以使用模拟来更改某些逻辑，而无需更改数据库逻辑本身。
例如，如果查询执行是有条件的，您可以模拟该条件（不在本例中）并仍然执行真正的查询。

     TEST_METHOD(IntegrationTest)
     {
            Server server;
            Database db(server);
            int QueryResult = db.Query("dummy expression");
            Assert::AreEqual(0, QueryResult);
     }

测试假实现，它调用模拟服务：
由于您的数据库使用 Server 类来执行查询，因此模拟 Server 基本上会将真正的连接带出游戏。
我使用 Typemock Isolator++ 进行模拟。我使用 FAKE_ALL 来模拟服务器的实例化，因为您的示例服务器是按值传递的（不是一个好主意），并且在传递时正在创建和复制它。
使用 FAKE_ALL 时，您将获得一个对象的代理 (fakeServer)，该对象替换代码中的服务器。代理上设置的所有行为都适用于代码中的对象 (server_)。

     TEST_METHOD(UnitTest)
     {
            Server* fakeServer = FAKE_ALL<Server>();
            WHEN_CALLED(fakeServer->ExecuteQuery()).Return(3);
            Database db(*fakeServer);

            int QueryResult = db.Query("dummy expression");

            Assert::AreEqual(3, QueryResult);
     }
};

Answer 2

您可以将测试的代码和模拟/伪造的代码放在它们自己的源文件中。然后您可以链接到您想要使用的任何版本。

我个人不会将测试代码与生产代码放在一起。这是一个单独的项目。

Answer 3

如果您想在运行时期间在数据库实现之间进行选择，那么显然您需要运行时多态性而不是静态多态性。因此，将依赖于“Database”概念的模板类 TestDatabaseContainer 更改为依赖于“Database”接口的常规类，并让 FakeDatabase 和真正的 Database 继承该接口：（

class IDatabase
{
public:
    int Query(const char* expression) = 0;
};
class TestDatabaseContainer 
{
 public:
  TestDatabaseContainer(IDatabase& d) : database_(d) {}
  int Query(const char* expression) {
    int result = database_.Query(expression);
    std::cout << "LOG: " << result << endl;
    return result; 
  }
private:
  IDatabase& database_;
};
class DatabaseTests 
{
 public:
  TestDatabaseContainer GetDb() 
  { 
      if(IntegrationTests)
          return TestDatabaseContainer(*(new Database));
      else 
          return TestDatabaseContainer(*(new FakeDatabase)); 
  }
};

我对任何内存泄漏不承担任何责任:)所以修改适当地）

Answer 4

如果数据库没有虚函数：

//ancestor of database containers
class TestDatabase
{
public:
  virtual int Query(const char* expression) = 0;
}; 
//TestDatabaseContainer is the same as in the example, but
//inherits TestDatabase
template <class T>
class TestDatabaseContainer: public TestDatabase
{
//...
};
class DatabaseTests 
{
 public:
  TestDatabase* GetDb() 
  { 
      if(IntegrationTests)
          return new TestDatabaseContainer<Database>();
      else 
          return new TestDatabaseContainer<FakeDatabase>();
  }
  //...
};