Frameworks stellen die Werkzeuge für eine schnelle Anwendungsentwicklung bereit, erhöhen jedoch häufig die technischen Schulden, je schneller Sie Funktionen erstellen. Technische Schulden treten auf, wenn die Wartbarkeit kein gezielter Fokus für Entwickler ist. Zukünftige Änderungen und Debugging sind kostspielig, da es an Unit-Tests und Struktur mangelt.
Hier erfahren Sie, wie Sie mit der Strukturierung Ihres Codes für Testbarkeit und Wartbarkeit beginnen – und Zeit sparen.
Beginnen wir mit einem erfundenen, aber typischen Code. Dies könnte eine Modellklasse in einem beliebigen Framework sein.
class User {
public function getCurrentUser()
{
$user_id = $_SESSION['user_id'];
$user = App::db->select('id, username')
->where('id', $user_id)
->limit(1)
->get();
if ( $user->num_results() > 0 )
{
return $user->row();
}
return false;
}
}
Dieser Code funktioniert, muss aber verbessert werden:
$_SESSION 全局变量。单元测试框架（例如 PHPUnit）依赖于命令行，其中 $_SESSION und viele andere globale Variablen angewiesen, die nicht verfügbar sind. App::db-Instanz ändern, die in der Anwendung verwendet wird. Und was ist, wenn wir die Informationen des aktuellen Benutzers nicht benötigen? Hier ist ein Versuch, einen Komponententest für die oben genannte Funktionalität zu erstellen.
class UserModelTest extends PHPUnit_Framework_TestCase {
public function testGetUser()
{
$user = new User();
$currentUser = $user->getCurrentUser();
$this->assertEquals(1, $currentUser->id);
}
}
Schauen wir uns das an. Erstens wird der Test fehlschlagen. User 对象中使用的 $_SESSION Die Variable existiert im Komponententest nicht, da sie PHP über die Befehlszeile ausführt.
Zweitens muss keine Datenbankverbindung eingerichtet werden. Das bedeutet, dass wir, damit dies funktioniert, unsere Anwendung booten müssen, um das App 对象及其 db-Objekt zu erhalten. Zum Testen benötigen wir außerdem eine funktionierende Datenbankverbindung.
Damit dieser Unit-Test funktioniert, benötigen wir:
Lassen Sie uns also mit der Diskussion darüber beginnen, wie wir dies verbessern können.
In diesem einfachen Kontext ist die Funktion zum Abrufen des aktuellen Benutzers unnötig. Dies ist ein erfundenes Beispiel, aber im Sinne des DRY-Prinzips bestand die erste Optimierung, für die ich mich entschieden habe, darin, diesen Ansatz zu verallgemeinern.
class User {
public function getUser($user_id)
{
$user = App::db->select('user')
->where('id', $user_id)
->limit(1)
->get();
if ( $user->num_results() > 0 )
{
return $user->row();
}
return false;
}
}
Dies stellt eine Methode bereit, die wir in unserer gesamten Anwendung verwenden können. Anstatt die Funktion an das Modell zu übergeben, können wir beim Aufruf den aktuellen Benutzer übergeben. Code ist modularer und wartbarer, wenn er nicht von anderen Funktionen wie globalen Sitzungsvariablen abhängt.
Allerdings kann dies immer noch nicht wie erwartet getestet und gewartet werden. Wir sind immer noch auf Datenbankverbindungen angewiesen.
Lassen Sie uns dazu beitragen, diese Situation zu verbessern, indem wir eine Abhängigkeitsinjektion hinzufügen. Wenn wir die Datenbankverbindung an die Klasse übergeben, könnte unser Modell so aussehen.
class User {
protected $_db;
public function __construct($db_connection)
{
$this->_db = $db_connection;
}
public function getUser($user_id)
{
$user = $this->_db->select('user')
->where('id', $user_id)
->limit(1)
->get();
if ( $user->num_results() > 0 )
{
return $user->row();
}
return false;
}
}
Jetzt werden die Abhängigkeiten unseres User Modells bereitgestellt. Unsere Klassen setzen keine bestimmte Datenbankanbindung mehr voraus und sind auch nicht von globalen Objekten abhängig.
Zu diesem Zeitpunkt ist unsere Klasse grundsätzlich zum Testen bereit. Wir können (meistens) eine Datenquelle unserer Wahl und eine Benutzer-ID übergeben und die Ergebnisse dieses Aufrufs testen. Wir können auch separate Datenbankverbindungen wechseln (vorausgesetzt, beide implementieren dieselbe Methode zum Abrufen von Daten). Cool.
Lassen Sie uns sehen, wie Unit-Tests aussehen könnten.
<?php
use Mockery as m;
use Fideloper\User;
class SecondUserTest extends PHPUnit_Framework_TestCase {
public function testGetCurrentUserMock()
{
$db_connection = $this->_mockDb();
$user = new User( $db_connection );
$result = $user->getUser( 1 );
$expected = new StdClass();
$expected->id = 1;
$expected->username = 'fideloper';
$this->assertEquals( $result->id, $expected->id, 'User ID set correctly' );
$this->assertEquals( $result->username, $expected->username, 'Username set correctly' );
}
protected function _mockDb()
{
// "Mock" (stub) database row result object
$returnResult = new StdClass();
$returnResult->id = 1;
$returnResult->username = 'fideloper';
// Mock database result object
$result = m::mock('DbResult');
$result->shouldReceive('num_results')->once()->andReturn( 1 );
$result->shouldReceive('row')->once()->andReturn( $returnResult );
// Mock database connection object
$db = m::mock('DbConnection');
$db->shouldReceive('select')->once()->andReturn( $db );
$db->shouldReceive('where')->once()->andReturn( $db );
$db->shouldReceive('limit')->once()->andReturn( $db );
$db->shouldReceive('get')->once()->andReturn( $result );
return $db;
}
}
Ich habe diesem Unit-Test etwas Neues hinzugefügt: Mockery. Mit Mockery können Sie PHP-Objekte „verspotten“ (fälschen). In diesem Beispiel simulieren wir eine Datenbankverbindung. Mit unserem Mock können wir das Testen der Datenbankverbindung überspringen und einfach unser Modell testen.
Möchten Sie mehr über Mockery erfahren?
In diesem Beispiel simulieren wir eine SQL-Verbindung. Wir teilen dem Scheinobjekt mit, dass es einen Aufruf des select、where、limit 和 get 方法。我返回 Mock 本身，以反映 SQL 连接对象如何返回自身 ($this)，从而使其方法调用“可链接”。请注意，对于 get 方法，我返回数据库调用结果 - 填充了用户数据的 stdClass-Objekts erwarten soll.
Das löst einige Probleme:
我们还可以做得更好。这就是它变得有趣的地方。
为了进一步改进这一点，我们可以定义并实现一个接口。考虑以下代码。
interface UserRepositoryInterface {
public function getUser($user_id);
}
class MysqlUserRepository implements UserRepositoryInterface {
protected $_db;
public function __construct($db_conn)
{
$this->_db = $db_conn;
}
public function getUser($user_id)
{
$user = $this->_db->select('user')
->where('id', $user_id)
->limit(1)
->get();
if ( $user->num_results() > 0 )
{
return $user->row();
}
return false;
}
}
class User {
protected $userStore;
public function __construct(UserRepositoryInterface $user)
{
$this->userStore = $user;
}
public function getUser($user_id)
{
return $this->userStore->getUser($user_id);
}
}
这里发生了一些事情。
addUser() 方法。User 模型中强制使用实现 UserInterface 的类。这样可以保证数据源始终有一个可用的 getUser() 方法，无论使用哪个数据源来实现 UserInterface。请注意，我们的
User对象类型提示UserInterface在其构造函数中。这意味着实现UserInterface的类必须传递到User对象中。这是我们所依赖的保证 - 我们需要getUser方法始终可用。
这样做的结果是什么？
User类，我们可以轻松地模拟数据源。 （测试数据源的实现将是单独的单元测试的工作）。User 对象。如果您决定放弃 SQL，则只需创建一个不同的实现（例如 MongoDbUser）并将其传递到您的 User 模型中。我们还简化了单元测试！
<?php
use Mockery as m;
use Fideloper\User;
class ThirdUserTest extends PHPUnit_Framework_TestCase {
public function testGetCurrentUserMock()
{
$userRepo = $this->_mockUserRepo();
$user = new User( $userRepo );
$result = $user->getUser( 1 );
$expected = new StdClass();
$expected->id = 1;
$expected->username = 'fideloper';
$this->assertEquals( $result->id, $expected->id, 'User ID set correctly' );
$this->assertEquals( $result->username, $expected->username, 'Username set correctly' );
}
protected function _mockUserRepo()
{
// Mock expected result
$result = new StdClass();
$result->id = 1;
$result->username = 'fideloper';
// Mock any user repository
$userRepo = m::mock('Fideloper\Third\Repository\UserRepositoryInterface');
$userRepo->shouldReceive('getUser')->once()->andReturn( $result );
return $userRepo;
}
}
我们已经完全取消了模拟数据库连接的工作。相反，我们只是模拟数据源，并告诉它当调用 getUser 时要做什么。
但是，我们仍然可以做得更好！
考虑我们当前代码的用法：
// In some controller
$user = new User( new MysqlUser( App:db->getConnection("mysql") ) );
$user->id = App::session("user->id");
$currentUser = $user->getUser($user_id);
我们的最后一步是引入容器。容器。在上面的代码中，我们需要创建并使用一堆对象来获取当前用户。此代码可能散布在您的应用程序中。如果您需要从 MySQL 切换到 MongoDB，您仍然需要编辑上述代码出现的每个位置。那几乎不是干的。容器可以解决这个问题。
容器只是“包含”一个对象或功能。它类似于应用程序中的注册表。我们可以使用容器自动实例化一个新的 User 对象以及所有需要的依赖项。下面，我使用 Pimple，一个流行的容器类。
// Somewhere in a configuration file
$container = new Pimple();
$container["user"] = function() {
return new User( new MysqlUser( App:db->getConnection('mysql') ) );
}
// Now, in all of our controllers, we can simply write:
$currentUser = $container['user']->getUser( App::session('user_id') );
我已将 User 模型的创建移至应用程序配置中的一个位置。结果是：
User 对象和选择的数据存储在我们应用程序的一个位置定义。User 模型从使用 MySQL 切换到 ONE 位置中的任何其他数据源。这更易于维护。在本教程的过程中，我们完成了以下任务：
我相信您已经注意到，我们以可维护性和可测试性的名义添加了更多代码。可以对这种实现提出强有力的论据：我们正在增加复杂性。事实上，这需要项目的主要作者和合作者对代码有更深入的了解。
但是，技术债务总体减少远远超过了解释和理解的成本。
您可以使用 Composer 轻松地将 Mockery 和 PHPUnit 包含到您的应用程序中。将这些添加到 composer.json 文件中的“require-dev”部分：
"require-dev": {
"mockery/mockery": "0.8.*",
"phpunit/phpunit": "3.7.*"
}
然后，您可以按照“dev”要求安装基于 Composer 的依赖项：
$ php composer.phar install --dev
在 Nettuts+ 上了解有关 Mockery、Composer 和 PHPUnit 的更多信息。
对于 PHP，请考虑使用 Laravel 4，因为它特别利用了容器和此处介绍的其他概念。
感谢您的阅读！
Das obige ist der detaillierte Inhalt vonErstellen Sie testbaren und wartbaren PHP-Code. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!
Der Unterschied zwischen Unix und Linux
So legen Sie die Transparenz der HTML-Schriftfarbe fest
Die Rolle des HTML-Titel-Tags
So lösen Sie das Problem, dass Apple nicht mehr als 200 Dateien herunterladen kann
Was ist eine relationale Datenbank?
Was bedeutet OS?
Es ist nicht möglich, das Standard-Gateway des Computers zu reparieren
So ändern Sie den Dateinamen unter Linux
![[Web-Frontend] Node.js-Schnellstart](https://img.php.cn/upload/course/000/000/067/662b5d34ba7c0227.png)
