require dirname(__DIR__) . '/vendor/autoload.php';
-$a = Factory\DependencyFactory::setUp('auth_ejabbered', dirname(__DIR__));
+$dice = new \Dice\Dice();
+$dice = $dice->addRules(include __DIR__ . '/../static/dependencies.config.php');
+
+$a = Factory\DependencyFactory::setUp('auth_ejabbered', $dice);
if ($a->getMode()->isNormal()) {
$oAuth = new ExAuth();
use Friendica\Factory;
-$a = Factory\DependencyFactory::setUp('console', dirname(__DIR__));
+$dice = new \Dice\Dice();
+$dice = $dice->addRules(include __DIR__ . '/../static/dependencies.config.php');
+
+$a = Factory\DependencyFactory::setUp('console', $dice);
\Friendica\BaseObject::setApp($a);
(new Friendica\Core\Console($argv))->execute();
require dirname(__DIR__) . '/vendor/autoload.php';
-$a = Factory\DependencyFactory::setUp('daemon', dirname(__DIR__));
+$dice = new \Dice\Dice();
+$dice = $dice->addRules(include __DIR__ . '/../static/dependencies.config.php');
+
+$a = Factory\DependencyFactory::setUp('daemon', $dice);
if ($a->getMode()->isInstall()) {
die("Friendica isn't properly installed yet.\n");
require dirname(__DIR__) . '/vendor/autoload.php';
-$a = Factory\DependencyFactory::setUp('worker', dirname(__DIR__));
+$dice = new \Dice\Dice();
+$dice = $dice->addRules(include __DIR__ . '/../static/dependencies.config.php');
+
+$a = Factory\DependencyFactory::setUp('worker', $dice);
// Check the database structure and possibly fixes it
Update::check($a->getBasePath(), true, $a->getMode());
require __DIR__ . '/vendor/autoload.php';
-$a = Factory\DependencyFactory::setUp('index', __DIR__, false);
+$dice = new \Dice\Dice();
+$dice = $dice->addRules(include __DIR__ . '/static/dependencies.config.php');
-$a->runFrontend();
+$a = Factory\DependencyFactory::setUp('index', $dice, false);
+$a->runFrontend();
$this->getMode()->determine($this->getBasePath());
if ($this->getMode()->has(App\Mode::DBAVAILABLE)) {
- $this->profiler->update(
- $this->config->get('system', 'profiler', false),
- $this->config->get('rendertime', 'callstack', false));
+ $this->profiler->update($this->config);
Core\Hook::loadHooks();
- $loader = new ConfigFileLoader($this->getBasePath(), $this->mode);
+ $loader = new ConfigFileLoader($this->getBasePath());
Core\Hook::callAll('load_config', $loader);
}
namespace Friendica\App;
-use Friendica\Core\Config;
-use Friendica\Database\DBA;
+use Friendica\Core\Config\Cache\ConfigCache;
+use Friendica\Database\Database;
+use Friendica\Util\BasePath;
/**
* Mode of the current Friendica Node
*/
private $basepath;
- public function __construct($basepath = '')
+ /**
+ * @var Database
+ */
+ private $database;
+
+ /**
+ * @var ConfigCache
+ */
+ private $configCache;
+
+ public function __construct(BasePath $basepath, Database $database, ConfigCache $configCache)
{
- $this->basepath = $basepath;
- $this->mode = 0;
+ $this->basepath = $basepath->getPath();
+ $this->database = $database;
+ $this->configCache = $configCache;
+ $this->mode = 0;
}
/**
* - App::MODE_MAINTENANCE: The maintenance mode has been set
* - App::MODE_NORMAL : Normal run with all features enabled
*
- * @param string $basepath the Basepath of the Application
+ * @param string $basePath the Basepath of the Application
+ *
+ * @return Mode returns itself
+ *
* @throws \Friendica\Network\HTTPException\InternalServerErrorException
*/
- public function determine($basepath = null)
+ public function determine($basePath = null)
{
- if (!empty($basepath)) {
- $this->basepath = $basepath;
+ if (!empty($basePath)) {
+ $this->basepath = $basePath;
}
$this->mode = 0;
if (!file_exists($this->basepath . '/config/local.config.php')
- && !file_exists($this->basepath . '/config/local.ini.php')
- && !file_exists($this->basepath . '/.htconfig.php')) {
- return;
+ && !file_exists($this->basepath . '/config/local.ini.php')
+ && !file_exists($this->basepath . '/.htconfig.php')) {
+ return $this;
}
$this->mode |= Mode::LOCALCONFIGPRESENT;
- if (!DBA::connected()) {
- return;
+ if (!$this->database->connected()) {
+ return $this;
}
$this->mode |= Mode::DBAVAILABLE;
- if (DBA::fetchFirst("SHOW TABLES LIKE 'config'") === false) {
- return;
+ if ($this->database->fetchFirst("SHOW TABLES LIKE 'config'") === false) {
+ return $this;
}
$this->mode |= Mode::DBCONFIGAVAILABLE;
- if (Config::get('system', 'maintenance')) {
- return;
+ if ($this->configCache->get('system', 'maintenance') ||
+ $this->database->selectFirst('config', ['v'], ['cat' => 'system', 'k' => 'maintenance'])) {
+ return $this;
}
$this->mode |= Mode::MAINTENANCEDISABLED;
+
+ return $this;
}
/**
public function isInstall()
{
return !$this->has(Mode::LOCALCONFIGPRESENT) ||
- !$this->has(MODE::DBCONFIGAVAILABLE);
+ !$this->has(MODE::DBCONFIGAVAILABLE);
}
/**
public function isNormal()
{
return $this->has(Mode::LOCALCONFIGPRESENT) &&
- $this->has(Mode::DBAVAILABLE) &&
- $this->has(Mode::DBCONFIGAVAILABLE) &&
- $this->has(Mode::MAINTENANCEDISABLED);
+ $this->has(Mode::DBAVAILABLE) &&
+ $this->has(Mode::DBCONFIGAVAILABLE) &&
+ $this->has(Mode::MAINTENANCEDISABLED);
}
-}
+}
\ No newline at end of file
$this->routeCollector->addRoute(['GET'], '/xrd', Module\Xrd::class);
}
- public function __construct(RouteCollector $routeCollector = null)
+ public function __construct()
{
- if (!$routeCollector) {
- $routeCollector = new RouteCollector(new Std(), new GroupCountBased());
- }
-
- $this->routeCollector = $routeCollector;
+ $this->routeCollector = new RouteCollector(new Std(), new GroupCountBased());
}
public function getRouteCollector()
namespace Friendica\Core\L10n;
+use Friendica\Core\Config\Configuration;
use Friendica\Core\Hook;
use Friendica\Core\Session;
use Friendica\Database\Database;
*/
private $logger;
- public function __construct(string $lang, Database $dba, LoggerInterface $logger)
+ public function __construct(Configuration $config, Database $dba, LoggerInterface $logger)
{
$this->dba = $dba;
$this->logger = $logger;
- $this->loadTranslationTable($lang);
+ $this->loadTranslationTable(L10n::detectLanguage($config->get('system', 'language', 'en')));
\Friendica\Core\L10n::init($this);
}
use mysqli;
use mysqli_result;
use mysqli_stmt;
-use ParagonIE\HiddenString\HiddenString;
use PDO;
use PDOException;
use PDOStatement;
private $in_transaction = false;
private $in_retrial = false;
private $relation = [];
- private $db_serveraddr;
- private $db_user;
- /**
- * @var HiddenString
- */
- private $db_pass;
- private $db_name;
- private $db_charset;
- public function __construct(ConfigCache $configCache, Profiler $profiler, LoggerInterface $logger, $serveraddr, $user, HiddenString $pass, $db, $charset = null)
+ public function __construct(ConfigCache $configCache, Profiler $profiler, LoggerInterface $logger, array $server)
{
// We are storing these values for being able to perform a reconnect
$this->configCache = $configCache;
$this->profiler = $profiler;
$this->logger = $logger;
- $this->db_serveraddr = $serveraddr;
- $this->db_user = $user;
- $this->db_pass = $pass;
- $this->db_name = $db;
- $this->db_charset = $charset;
+ $this->readServerVariables($server);
$this->connect();
DBA::init($this);
}
+ private function readServerVariables(array $server)
+ {
+ // Use environment variables for mysql if they are set beforehand
+ if (!empty($server['MYSQL_HOST'])
+ && !empty($server['MYSQL_USERNAME'] || !empty($server['MYSQL_USER']))
+ && $server['MYSQL_PASSWORD'] !== false
+ && !empty($server['MYSQL_DATABASE']))
+ {
+ $db_host = $server['MYSQL_HOST'];
+ if (!empty($server['MYSQL_PORT'])) {
+ $db_host .= ':' . $server['MYSQL_PORT'];
+ }
+ $this->configCache->set('database', 'hostname', $db_host);
+ unset($db_host);
+ if (!empty($server['MYSQL_USERNAME'])) {
+ $this->configCache->set('database', 'username', $server['MYSQL_USERNAME']);
+ } else {
+ $this->configCache->set('database', 'username', $server['MYSQL_USER']);
+ }
+ $this->configCache->set('database', 'password', (string) $server['MYSQL_PASSWORD']);
+ $this->configCache->set('database', 'database', $server['MYSQL_DATABASE']);
+ }
+ }
+
public function connect()
{
if (!is_null($this->connection) && $this->connected()) {
}
$port = 0;
- $serveraddr = trim($this->db_serveraddr);
-
+ $serveraddr = trim($this->configCache->get('database', 'hostname'));
$serverdata = explode(':', $serveraddr);
$server = $serverdata[0];
-
if (count($serverdata) > 1) {
$port = trim($serverdata[1]);
}
-
$server = trim($server);
- $user = trim($this->db_user);
- $pass = trim($this->db_pass);
- $db = trim($this->db_name);
- $charset = trim($this->db_charset);
+ $user = trim($this->configCache->get('database', 'username'));
+ $pass = trim($this->configCache->get('database', 'password'));
+ $db = trim($this->configCache->get('database', 'database'));
+ $charset = trim($this->configCache->get('database', 'charset'));
if (!(strlen($server) && strlen($user))) {
return false;
use Friendica\Core;
use Friendica\Core\Config;
use Friendica\Core\Config\Cache;
-use Friendica\Util\ConfigFileLoader;
use Friendica\Model\Config\Config as ConfigModel;
use Friendica\Model\Config\PConfig as PConfigModel;
+use Friendica\Util\ConfigFileLoader;
class ConfigFactory
{
*
* @return Cache\ConfigCache
*/
- public static function createCache(ConfigFileLoader $loader)
+ public function createCache(ConfigFileLoader $loader)
{
$configCache = new Cache\ConfigCache();
$loader->setupCache($configCache);
/**
* @param Cache\ConfigCache $configCache The config cache of this adapter
- * @param ConfigModel $configModel The configuration model
+ * @param ConfigModel $configModel The configuration model
*
* @return Config\Configuration
*/
- public static function createConfig(Cache\ConfigCache $configCache, ConfigModel $configModel)
+ public function createConfig(Cache\ConfigCache $configCache, ConfigModel $configModel)
{
if ($configCache->get('system', 'config_adapter') === 'preload') {
$configuration = new Config\PreloadConfiguration($configCache, $configModel);
}
/**
- * @param Cache\ConfigCache $configCache The config cache
- * @param Cache\PConfigCache $pConfigCache The personal config cache
- * @param PConfigModel $configModel The configuration model
+ * @param Cache\ConfigCache $configCache The config cache
+ * @param Cache\PConfigCache $pConfigCache The personal config cache
+ * @param PConfigModel $configModel The configuration model
*
* @return Config\PConfiguration
*/
- public static function createPConfig(Cache\ConfigCache $configCache, Cache\PConfigCache $pConfigCache, PConfigModel $configModel)
+ public function createPConfig(Cache\ConfigCache $configCache, Cache\PConfigCache $pConfigCache, PConfigModel $configModel)
{
if ($configCache->get('system', 'config_adapter') === 'preload') {
$configuration = new Config\PreloadPConfiguration($pConfigCache, $configModel);
+++ /dev/null
-<?php
-
-namespace Friendica\Factory;
-
-use Friendica\Core\Config\Cache;
-use Friendica\Database;
-use Friendica\Util\Logger\VoidLogger;
-use Friendica\Util\Profiler;
-use ParagonIE\HiddenString\HiddenString;
-
-class DBFactory
-{
- /**
- * Initialize the DBA connection
- *
- * @param Cache\ConfigCache $configCache The configuration cache
- * @param Profiler $profiler The profiler
- * @param array $server The $_SERVER variables
- *
- * @return Database\Database
- * @throws \Exception if connection went bad
- */
- public static function init(Cache\ConfigCache $configCache, Profiler $profiler, array $server)
- {
- $db_host = $configCache->get('database', 'hostname');
- $db_user = $configCache->get('database', 'username');
- $db_pass = $configCache->get('database', 'password');
- $db_data = $configCache->get('database', 'database');
- $charset = $configCache->get('database', 'charset');
-
- // Use environment variables for mysql if they are set beforehand
- if (!empty($server['MYSQL_HOST'])
- && !empty($server['MYSQL_USERNAME'] || !empty($server['MYSQL_USER']))
- && $server['MYSQL_PASSWORD'] !== false
- && !empty($server['MYSQL_DATABASE']))
- {
- $db_host = $server['MYSQL_HOST'];
- if (!empty($server['MYSQL_PORT'])) {
- $db_host .= ':' . $server['MYSQL_PORT'];
- }
- if (!empty($server['MYSQL_USERNAME'])) {
- $db_user = $server['MYSQL_USERNAME'];
- } else {
- $db_user = $server['MYSQL_USER'];
- }
- $db_pass = new HiddenString((string) $server['MYSQL_PASSWORD']);
- $db_data = $server['MYSQL_DATABASE'];
- }
-
- $database = new Database\Database($configCache, $profiler, new VoidLogger(), $db_host, $db_user, $db_pass, $db_data, $charset);
-
- if ($database->connected()) {
- // Loads DB_UPDATE_VERSION constant
- Database\DBStructure::definition($configCache->get('system', 'basepath'), false);
- }
-
- unset($db_host, $db_user, $db_pass, $db_data, $charset);
-
- return $database;
- }
-}
namespace Friendica\Factory;
+use Dice\Dice;
use Friendica\App;
-use Friendica\Core\Config\Cache\PConfigCache;
-use Friendica\Core\L10n\L10n;
-use Friendica\Factory;
-use Friendica\Util\BasePath;
-use Friendica\Util\BaseURL;
-use Friendica\Util\ConfigFileLoader;
+use Friendica\Core\Config\PConfiguration;
+use Psr\Log\LoggerInterface;
class DependencyFactory
{
* Setting all default-dependencies of a friendica execution
*
* @param string $channel The channel of this execution
- * @param string $directory The base directory
* @param bool $isBackend True, if it's a backend execution, otherwise false (Default true)
*
* @return App The application
*
* @throws \Exception
*/
- public static function setUp($channel, $directory, $isBackend = true)
+ public static function setUp($channel, Dice $dice, $isBackend = true)
{
- $basePath = BasePath::create($directory, $_SERVER);
- $mode = new App\Mode($basePath);
- $router = new App\Router();
- $configLoader = new ConfigFileLoader($basePath, $mode);
- $configCache = Factory\ConfigFactory::createCache($configLoader);
- $profiler = Factory\ProfilerFactory::create($configCache);
- $database = Factory\DBFactory::init($configCache, $profiler, $_SERVER);
- $configModel = new \Friendica\Model\Config\Config($database);
- $config = Factory\ConfigFactory::createConfig($configCache, $configModel);
- // needed to call PConfig::init()
- $pconfigModel = new \Friendica\Model\Config\PConfig($database);
- Factory\ConfigFactory::createPConfig($configCache, new PConfigCache(), $pconfigModel);
- $logger = Factory\LoggerFactory::create($channel, $database, $config, $profiler);
- Factory\LoggerFactory::createDev($channel, $config, $profiler);
- $baseURL = new BaseURL($config, $_SERVER);
- $l10n = new L10n(L10n::detectLanguage($config->get('system', 'language')),
- $database,
- $logger);
+ $pConfig = $dice->create(PConfiguration::class);
+ $logger = $dice->create(LoggerInterface::class, [$channel]);
+ $devLogger = $dice->create('$devLogger', [$channel]);
- return new App($database, $config, $mode, $router, $baseURL, $logger, $profiler, $l10n, $isBackend);
+ return $dice->create(App::class, [$isBackend]);
}
}
* @throws \Exception
* @throws InternalServerErrorException
*/
- public static function create($channel, Database $database, Configuration $config, Profiler $profiler)
+ public function create($channel, Database $database, Configuration $config, Profiler $profiler)
{
if (empty($config->get('system', 'debugging', false))) {
$logger = new VoidLogger();
+++ /dev/null
-<?php
-
-namespace Friendica\Factory;
-
-use Friendica\Core\Config\Cache\ConfigCache;
-use Friendica\Util\Profiler;
-
-class ProfilerFactory
-{
- /**
- * Creates a Profiler for the current execution
- *
- * @param ConfigCache $configCache The configuration cache
- *
- * @return Profiler
- */
- public static function create(ConfigCache $configCache)
- {
- $enabled = $configCache->get('system', 'profiler');
- $enabled = isset($enabled) && $enabled !== '0';
- $renderTime = $configCache->get('rendertime', 'callstack');
- $renderTime = isset($renderTime) && $renderTime !== '0';
-
- return new Profiler($enabled, $renderTime);
- }
-}
class BasePath
{
+ /**
+ * @var string
+ */
+ private $baseDir;
+ /**
+ * @var array
+ */
+ private $server;
+
+ /**
+ * @param string|null $baseDir The default base path
+ * @param array $server server arguments
+ */
+ public function __construct(string $baseDir, array $server = [])
+ {
+ $this->baseDir = $baseDir;
+ $this->server = $server;
+ }
+
/**
* @brief Returns the base filesystem path of the App
*
* It first checks for the internal variable, then for DOCUMENT_ROOT and
* finally for PWD
*
- * @param string|null $basePath The default base path
- * @param array $server server arguments
- *
* @return string
*
* @throws \Exception if directory isn't usable
*/
- public static function create($basePath, array $server = [])
+ public function getPath()
{
- if ((!$basePath || !is_dir($basePath)) && !empty($server['DOCUMENT_ROOT'])) {
- $basePath = $server['DOCUMENT_ROOT'];
+ $baseDir = $this->baseDir;
+ $server = $this->server;
+
+ if ((!$baseDir || !is_dir($baseDir)) && !empty($server['DOCUMENT_ROOT'])) {
+ $baseDir = $server['DOCUMENT_ROOT'];
}
- if ((!$basePath || !is_dir($basePath)) && !empty($server['PWD'])) {
- $basePath = $server['PWD'];
+ if ((!$baseDir || !is_dir($baseDir)) && !empty($server['PWD'])) {
+ $baseDir = $server['PWD'];
}
- $basePath = self::getRealPath($basePath);
+ $baseDir = self::getRealPath($baseDir);
- if (!is_dir($basePath)) {
- throw new \Exception(sprintf('\'%s\' is not a valid basepath', $basePath));
+ if (!is_dir($baseDir)) {
+ throw new \Exception(sprintf('\'%s\' is not a valid basepath', $baseDir));
}
- return $basePath;
+ return $baseDir;
}
/**
namespace Friendica\Util;
use Exception;
-use Friendica\App;
use Friendica\Core\Addon;
use Friendica\Core\Config\Cache\ConfigCache;
*/
const SAMPLE_END = '-sample';
- /**
- * @var App\Mode
- */
- private $appMode;
/**
* @var string
*/
*/
private $staticDir;
- public function __construct($baseDir, App\Mode $mode)
+ public function __construct(string $basePath)
{
- $this->baseDir = $baseDir;
- $this->configDir = $baseDir . DIRECTORY_SEPARATOR . self::CONFIG_DIR;
- $this->staticDir = $baseDir . DIRECTORY_SEPARATOR . self::STATIC_DIR;
- $this->appMode = $mode;
+ $this->baseDir = $basePath;
+ $this->configDir = $this->baseDir . DIRECTORY_SEPARATOR . self::CONFIG_DIR;
+ $this->staticDir = $this->baseDir . DIRECTORY_SEPARATOR . self::STATIC_DIR;
}
/**
$this->loadCoreConfig($config);
// In case of install mode, add the found basepath (because there isn't a basepath set yet
- if (!$raw && ($this->appMode->isInstall() || empty($config->get('system', 'basepath')))) {
+ if (!$raw && empty($config->get('system', 'basepath'))) {
// Setting at least the basepath we know
$config->set('system', 'basepath', $this->baseDir);
}
namespace Friendica\Util;
+use Friendica\Core\Config\Cache\ConfigCache;
+use Friendica\Core\Config\Configuration;
use Psr\Container\ContainerExceptionInterface;
use Psr\Container\ContainerInterface;
use Psr\Container\NotFoundExceptionInterface;
/**
* Updates the enabling of the current profiler
*
- * @param bool $enabled
- * @param bool $renderTime
+ * @param Configuration $config
*/
- public function update($enabled = false, $renderTime = false)
+ public function update(Configuration $config)
{
- $this->enabled = $enabled;
- $this->rendertime = $renderTime;
+ $this->enabled = $config->get('system', 'profiler');
+ $this->rendertime = $config->get('rendertime', 'callstack');
}
/**
- * @param bool $enabled True, if the Profiler is enabled
- * @param bool $renderTime True, if the Profiler should measure the whole rendertime including functions
+ * @param ConfigCache $configCache The configuration cache
*/
- public function __construct($enabled = false, $renderTime = false)
+ public function __construct(ConfigCache $configCache)
{
- $this->enabled = $enabled;
- $this->rendertime = $renderTime;
+ $this->enabled = $configCache->get('system', 'profiler');
+ $this->rendertime = $configCache->get('rendertime', 'callstack');
$this->reset();
}
--- /dev/null
+<?php
+
+use Dice\Dice;
+use Friendica\App;
+use Friendica\Core\Config;
+use Friendica\Database\Database;
+use Friendica\Factory;
+use Friendica\Util;
+use Psr\Log\LoggerInterface;
+
+/**
+ * The configuration defines "complex" dependencies inside Friendica
+ * So this classes shouldn't be simple or their dependencies are already defined here.
+ *
+ * This kind of dependencies are NOT required to be defined here:
+ * - $a = new ClassA(new ClassB());
+ * - $a = new ClassA();
+ * - $a = new ClassA(Configuration $configuration);
+ *
+ * This kind of dependencies SHOULD be defined here:
+ * - $a = new ClassA();
+ * $b = $a->create();
+ *
+ * - $a = new ClassA($creationPassedVariable);
+ *
+ */
+return [
+ '$basepath' => [
+ 'instanceOf' => Util\BasePath::class,
+ 'call' => [
+ ['getPath', [], Dice::CHAIN_CALL],
+ ],
+ 'constructParams' => [
+ dirname(__FILE__, 2),
+ $_SERVER
+ ]
+ ],
+ Util\BasePath::class => [
+ 'shared' => true,
+ 'constructParams' => [
+ dirname(__FILE__, 2),
+ $_SERVER
+ ]
+ ],
+ Util\ConfigFileLoader::class => [
+ 'shared' => true,
+ 'constructParams' => [
+ [Dice::INSTANCE => '$basepath'],
+ ],
+ ],
+ Config\Cache\ConfigCache::class => [
+ 'instanceOf' => Factory\ConfigFactory::class,
+ 'call' => [
+ ['createCache', [], Dice::CHAIN_CALL],
+ ],
+ 'shared' => true,
+ ],
+ App\Mode::class => [
+ 'call' => [
+ ['determine', [], Dice::CHAIN_CALL],
+ ],
+ // marks the result as shared for other creations, so there's just
+ // one instance for the whole execution
+ 'shared' => true,
+ ],
+ Config\Configuration::class => [
+ 'shared' => true,
+ 'instanceOf' => Factory\ConfigFactory::class,
+ 'call' => [
+ ['createConfig', [], Dice::CHAIN_CALL],
+ ],
+ ],
+ Config\PConfiguration::class => [
+ 'shared' => true,
+ 'instanceOf' => Factory\ConfigFactory::class,
+ 'call' => [
+ ['createPConfig', [], Dice::CHAIN_CALL],
+ ]
+ ],
+ Database::class => [
+ 'shared' => true,
+ 'constructParams' => [
+ [DICE::INSTANCE => \Psr\Log\NullLogger::class],
+ $_SERVER,
+ ],
+ ],
+ /**
+ * Creates the Util\BaseURL
+ *
+ * Same as:
+ * $baseURL = new Util\BaseURL($configuration, $_SERVER);
+ */
+ Util\BaseURL::class => [
+ 'shared' => true,
+ 'constructParams' => [
+ $_SERVER,
+ ],
+ ],
+ /**
+ * Create a Logger, which implements the LoggerInterface
+ *
+ * Same as:
+ * $loggerFactory = new Factory\LoggerFactory();
+ * $logger = $loggerFactory->create($channel, $configuration, $profiler);
+ *
+ * Attention1: We can use DICE for detecting dependencies inside "chained" calls too
+ * Attention2: The variable "$channel" is passed inside the creation of the dependencies per:
+ * $app = $dice->create(App::class, [], ['$channel' => 'index']);
+ * and is automatically passed as an argument with the same name
+ */
+ LoggerInterface::class => [
+ 'shared' => true,
+ 'instanceOf' => Factory\LoggerFactory::class,
+ 'call' => [
+ ['create', [], Dice::CHAIN_CALL],
+ ],
+ ],
+ '$devLogger' => [
+ 'shared' => true,
+ 'instanceOf' => Factory\LoggerFactory::class,
+ 'call' => [
+ ['createDev', [], Dice::CHAIN_CALL],
+ ]
+ ]
+];
use PHPUnit\DbUnit\DataSet\YamlDataSet;
use PHPUnit\DbUnit\TestCaseTrait;
use PHPUnit_Extensions_Database_DB_IDatabaseConnection;
+use Psr\Log\NullLogger;
require_once __DIR__ . '/../boot.php';
{
parent::setUpBeforeClass();
- self::$basePath = BasePath::create(dirname(__DIR__));
- self::$mode = new Mode(self::$basePath);
- $configLoader = new ConfigFileLoader(self::$basePath, self::$mode);
- self::$configCache = ConfigFactory::createCache($configLoader);
- self::$profiler = ProfilerFactory::create(self::$configCache);
- self::$dba = DBFactory::init(self::$configCache, self::$profiler, $_SERVER);
+ self::$basePath = new BasePath(dirname(__DIR__));
+ $configLoader = new ConfigFileLoader(self::$basePath->getPath());
+ $configFactory = new ConfigFactory();
+ self::$configCache = $configFactory->createCache($configLoader);
+ self::$profiler = new Profiler(self::$configCache);
+ self::$dba = new Database(self::$configCache, self::$profiler, new NullLogger(), $_SERVER);
+ self::$mode = new Mode(self::$basePath, self::$dba, self::$configCache);
}
/**
--- /dev/null
+<?php
+
+namespace functional;
+
+use Dice\Dice;
+use Friendica\App;
+use Friendica\Core\Config\Cache\ConfigCache;
+use Friendica\Core\Config\Configuration;
+use Friendica\Database\Database;
+use Friendica\Test\Util\VFSTrait;
+use Friendica\Util\BasePath;
+use Friendica\Util\ConfigFileLoader;
+use Friendica\Util\Profiler;
+use PHPUnit\Framework\TestCase;
+use Psr\Log\LoggerInterface;
+
+class dependencyCheck extends TestCase
+{
+ use VFSTrait;
+
+ /**
+ * @var Dice
+ */
+ private $dice;
+
+ protected function setUp()
+ {
+ parent::setUp();
+
+ $this->setUpVfsDir();
+
+ $this->dice = new Dice();
+ $this->dice = $this->dice->addRules(include __DIR__ . '/../../static/dependencies.config.php');
+ }
+
+ /**
+ * Test the creation of the BasePath
+ */
+ public function testBasePath()
+ {
+ /** @var BasePath $basePath */
+ $basePath = $this->dice->create(BasePath::class, [$this->root->url()]);
+
+ $this->assertInstanceOf(BasePath::class, $basePath);
+ $this->assertEquals($this->root->url(), $basePath->getPath());
+ }
+
+ /**
+ * Test the initial config cache
+ * Should not need any other files
+ */
+ public function testConfigFileLoader()
+ {
+ /** @var ConfigFileLoader $configFileLoader */
+ $configFileLoader = $this->dice->create(ConfigFileLoader::class);
+
+ $this->assertInstanceOf(ConfigFileLoader::class, $configFileLoader);
+
+ $configCache = new ConfigCache();
+ $configFileLoader->setupCache($configCache);
+
+ $this->assertNotEmpty($configCache->getAll());
+ $this->assertArrayHasKey('database', $configCache->getAll());
+ $this->assertArrayHasKey('system', $configCache->getAll());
+ }
+
+ /**
+ * Test the construction of a profiler class with DI
+ */
+ public function testProfiler()
+ {
+ /** @var Profiler $profiler */
+ $profiler = $this->dice->create(Profiler::class);
+
+ $this->assertInstanceOf(Profiler::class, $profiler);
+
+ $configCache = new ConfigCache([
+ 'system' => [
+ 'profiler' => true,
+ ],
+ 'rendertime' => [
+ 'callstack' => true,
+ ]
+ ]);
+
+ $profiler = $this->dice->create(Profiler::class, [$configCache]);
+
+ $this->assertInstanceOf(Profiler::class, $profiler);
+ $this->assertTrue($profiler->isRendertime());
+ }
+
+ public function testDatabase()
+ {
+ /** @var Database $database */
+ $database = $this->dice->create(Database::class);
+
+ $this->assertInstanceOf(Database::class, $database);
+ $this->assertTrue($database->connected());
+ }
+
+ public function testAppMode()
+ {
+ /** @var App\Mode $mode */
+ $mode = $this->dice->create(App\Mode::class);
+
+ $this->assertInstanceOf(App\Mode::class, $mode);
+
+ $this->assertTrue($mode->isNormal());
+ }
+
+ public function testConfiguration()
+ {
+ /** @var Configuration $config */
+ $config = $this->dice->create(Configuration::class);
+
+ $this->assertInstanceOf(Configuration::class, $config);
+
+ $this->assertNotEmpty($config->get('database', 'username'));
+ }
+
+ public function testLogger()
+ {
+ /** @var LoggerInterface $logger */
+ $logger = $this->dice->create(LoggerInterface::class, ['test']);
+
+ $this->assertInstanceOf(LoggerInterface::class, $logger);
+ }
+
+ public function testDevLogger()
+ {
+ /** @var LoggerInterface $logger */
+ $logger = $this->dice->create('$devLogger', ['dev']);
+
+ self::assertInstanceOf(LoggerInterface::class, $logger);
+ }
+}
use Friendica\Factory;
use Friendica\Network\HTTPException;
use Friendica\Util\BaseURL;
-use Friendica\Util\ConfigFileLoader;
use Monolog\Handler\TestHandler;
require_once __DIR__ . '/../../include/api.php';
public function setUp()
{
$configModel = new \Friendica\Model\Config\Config(self::$dba);
- $config = Factory\ConfigFactory::createConfig(self::$configCache, $configModel);
+ $configFactory = new Factory\ConfigFactory();
+ $config = $configFactory->createConfig(self::$configCache, $configModel);
$pconfigModel = new \Friendica\Model\Config\PConfig(self::$dba);
- Factory\ConfigFactory::createPConfig(self::$configCache, new PConfigCache(), $pconfigModel);
- $logger = Factory\LoggerFactory::create('test', self::$dba, $config, self::$profiler);
+ $configFactory->createPConfig(self::$configCache, new PConfigCache(), $pconfigModel);
+ $loggerFactory = new Factory\LoggerFactory();
+ $logger = $loggerFactory->create('test', self::$dba, $config, self::$profiler);
$baseUrl = new BaseURL($config, $_SERVER);
$router = new App\Router();
- $l10n = new L10n(L10n::detectLanguage($config->get('system', 'language')),
+ $l10n = new L10n($config,
self::$dba,
$logger);
$this->app = new App(self::$dba, $config, self::$mode, $router, $baseUrl, $logger, self::$profiler, $l10n, false);
use Friendica\App\Mode;
use Friendica\Core\Config;
+use Friendica\Database\Database;
use Friendica\Test\MockedTest;
use Friendica\Test\Util\DBAMockTrait;
use Friendica\Test\Util\VFSTrait;
+use Friendica\Util\BasePath;
+use Mockery\MockInterface;
class ModeTest extends MockedTest
{
use VFSTrait;
use DBAMockTrait;
+ /**
+ * @var BasePath|MockInterface
+ */
+ private $basePathMock;
+
+ /**
+ * @var Database|MockInterface
+ */
+ private $databaseMock;
+
+ /**
+ * @var Config\Cache\ConfigCache|MockInterface
+ */
+ private $configCacheMock;
+
public function setUp()
{
parent::setUp();
$this->setUpVfsDir();
+
+ $this->basePathMock = \Mockery::mock(BasePath::class);
+ $this->basePathMock->shouldReceive('getPath')->andReturn($this->root->url())->once();
+
+ $this->databaseMock = \Mockery::mock(Database::class);
+ $this->configCacheMock = \Mockery::mock(Config\Cache\ConfigCache::class);
}
public function testItEmpty()
{
- $mode = new Mode($this->root->url());
+ $mode = new Mode($this->basePathMock, $this->databaseMock, $this->configCacheMock);
$this->assertTrue($mode->isInstall());
$this->assertFalse($mode->isNormal());
}
public function testWithoutConfig()
{
- $mode = new Mode($this->root->url());
+ $mode = new Mode($this->basePathMock, $this->databaseMock, $this->configCacheMock);
$this->assertTrue($this->root->hasChild('config/local.config.php'));
$this->assertFalse($mode->has(Mode::LOCALCONFIGPRESENT));
}
- /**
- * @runInSeparateProcess
- * @preserveGlobalState disabled
- */
public function testWithoutDatabase()
{
- $this->mockConnected(false, 1);
+ $this->databaseMock->shouldReceive('connected')->andReturn(false)->once();
- $mode = new Mode($this->root->url());
+ $mode = new Mode($this->basePathMock, $this->databaseMock, $this->configCacheMock);
$mode->determine();
$this->assertFalse($mode->isNormal());
$this->assertFalse($mode->has(Mode::DBAVAILABLE));
}
- /**
- * @runInSeparateProcess
- * @preserveGlobalState disabled
- */
public function testWithoutDatabaseSetup()
{
- $this->mockConnected(true, 1);
- $this->mockFetchFirst('SHOW TABLES LIKE \'config\'', false, 1);
+ $this->databaseMock->shouldReceive('connected')->andReturn(true)->once();
+ $this->databaseMock->shouldReceive('fetchFirst')
+ ->with('SHOW TABLES LIKE \'config\'')->andReturn(false)->once();
- $mode = new Mode($this->root->url());
+ $mode = new Mode($this->basePathMock, $this->databaseMock, $this->configCacheMock);
$mode->determine();
$this->assertFalse($mode->isNormal());
$this->assertTrue($mode->has(Mode::LOCALCONFIGPRESENT));
}
- /**
- * @runInSeparateProcess
- * @preserveGlobalState disabled
- */
public function testWithMaintenanceMode()
{
- $this->mockConnected(true, 1);
- $this->mockFetchFirst('SHOW TABLES LIKE \'config\'', true, 1);
-
- $config = \Mockery::mock(Config\Configuration::class);
- $config
- ->shouldReceive('get')
- ->with('system', 'maintenance', null, false)
- ->andReturn(true)
- ->once();
- // Initialize empty Config
- Config::init($config);
-
- $mode = new Mode($this->root->url());
+ $this->databaseMock->shouldReceive('connected')->andReturn(true)->once();
+ $this->databaseMock->shouldReceive('fetchFirst')
+ ->with('SHOW TABLES LIKE \'config\'')->andReturn(true)->once();
+ $this->configCacheMock->shouldReceive('get')->with('system', 'maintenance')
+ ->andReturn(true)->once();
+
+ $mode = new Mode($this->basePathMock, $this->databaseMock, $this->configCacheMock);
$mode->determine();
$this->assertFalse($mode->isNormal());
$this->assertFalse($mode->has(Mode::MAINTENANCEDISABLED));
}
- /**
- * @runInSeparateProcess
- * @preserveGlobalState disabled
- */
public function testNormalMode()
{
- $this->mockConnected(true, 1);
- $this->mockFetchFirst('SHOW TABLES LIKE \'config\'', true, 1);
-
- $config = \Mockery::mock(Config\Configuration::class);
- $config
- ->shouldReceive('get')
- ->with('system', 'maintenance', null, false)
- ->andReturn(false)
- ->once();
- // Initialize empty Config
- Config::init($config);
-
- $mode = new Mode($this->root->url());
+ $this->databaseMock->shouldReceive('connected')->andReturn(true)->once();
+ $this->databaseMock->shouldReceive('fetchFirst')
+ ->with('SHOW TABLES LIKE \'config\'')->andReturn(true)->once();
+ $this->configCacheMock->shouldReceive('get')->with('system', 'maintenance')
+ ->andReturn(false)->once();
+ $this->databaseMock->shouldReceive('selectFirst')
+ ->with('config', ['v'], ['cat' => 'system', 'k' => 'maintenance'])
+ ->andReturn(false)->once();
+
+ $mode = new Mode($this->basePathMock, $this->databaseMock, $this->configCacheMock);
$mode->determine();
$this->assertTrue($mode->isNormal());
$logger = Factory\LoggerFactory::create('test', self::$dba, $config, self::$profiler);
$baseUrl = new BaseURL($config, $_SERVER);
$router = new App\Router();
- $l10n = new L10n(L10n::detectLanguage($config->get('system', 'language')),
+ $l10n = new L10n($config,
self::$dba,
$logger);
$this->app = new App(self::$dba, $config, self::$mode, $router, $baseUrl, $logger, self::$profiler, $l10n, false);
$logger = Factory\LoggerFactory::create('test', self::$dba, $config, self::$profiler);
$baseUrl = new BaseURL($config, $_SERVER);
$router = new App\Router();
- $l10n = new L10n(L10n::detectLanguage($config->get('system', 'language')),
+ $l10n = new L10n($config,
self::$dba,
$logger);
$this->app = new App(self::$dba, $config, self::$mode, $router, $baseUrl, $logger, self::$profiler, $l10n, false);
*/
public function testDetermineBasePath(array $server, $input, $output)
{
- $this->assertEquals($output, BasePath::create($input, $server));
+ $basepath = new BasePath($input, $server);
+ $this->assertEquals($output, $basepath->getPath());
}
/**
*/
public function testFailedBasePath()
{
- BasePath::create('/now23452sgfgas', []);
+ $basepath = new BasePath('/now23452sgfgas', []);
+ $basepath->getPath();
}
}
namespace Friendica\Test\src\Util\Config;
-use Friendica\App;
use Friendica\Core\Config\Cache\ConfigCache;
use Friendica\Test\MockedTest;
use Friendica\Test\Util\VFSTrait;
use Friendica\Util\ConfigFileLoader;
-use Mockery\MockInterface;
use org\bovigo\vfs\vfsStream;
class ConfigFileLoaderTest extends MockedTest
{
use VFSTrait;
- /**
- * @var App\Mode|MockInterface
- */
- private $mode;
-
protected function setUp()
{
parent::setUp();
$this->setUpVfsDir();
-
- $this->mode = \Mockery::mock(App\Mode::class);
- $this->mode->shouldReceive('isInstall')->andReturn(true);
}
/**
*/
public function testLoadConfigFiles()
{
- $configFileLoader = new ConfigFileLoader($this->root->url(), $this->mode);
+ $this->delConfigFile('local.config.php');
+
+ $configFileLoader = new ConfigFileLoader($this->root->url());
$configCache = new ConfigCache();
$configFileLoader->setupCache($configCache);
->at($this->root->getChild('config'))
->setContent('<?php return true;');
- $configFileLoader = new ConfigFileLoader($this->root->url(), $this->mode);
+ $configFileLoader = new ConfigFileLoader($this->root->url());
$configCache = new ConfigCache();
$configFileLoader->setupCache($configCache);
->at($this->root->getChild('config'))
->setContent(file_get_contents($file));
- $configFileLoader = new ConfigFileLoader($this->root->url(), $this->mode);
+ $configFileLoader = new ConfigFileLoader($this->root->url());
$configCache = new ConfigCache();
$configFileLoader->setupCache($configCache);
->at($this->root->getChild('config'))
->setContent(file_get_contents($file));
- $configFileLoader = new ConfigFileLoader($this->root->url(), $this->mode);
+ $configFileLoader = new ConfigFileLoader($this->root->url());
$configCache = new ConfigCache();
$configFileLoader->setupCache($configCache);
->at($this->root)
->setContent(file_get_contents($file));
- $configFileLoader = new ConfigFileLoader($this->root->url(), $this->mode);
+ $configFileLoader = new ConfigFileLoader($this->root->url());
$configCache = new ConfigCache();
$configFileLoader->setupCache($configCache);
->at($this->root->getChild('addon')->getChild('test')->getChild('config'))
->setContent(file_get_contents($file));
- $configFileLoader = new ConfigFileLoader($this->root->url(), $this->mode);
+ $configFileLoader = new ConfigFileLoader($this->root->url());
$conf = $configFileLoader->loadAddonConfig('test');
->at($this->root->getChild('config'))
->setContent(file_get_contents($fileDir . 'B.config.php'));
- $configFileLoader = new ConfigFileLoader($this->root->url(), $this->mode);
+ $configFileLoader = new ConfigFileLoader($this->root->url());
$configCache = new ConfigCache();
$configFileLoader->setupCache($configCache);
->at($this->root->getChild('config'))
->setContent(file_get_contents($fileDir . 'B.ini.php'));
- $configFileLoader = new ConfigFileLoader($this->root->url(), $this->mode);
+ $configFileLoader = new ConfigFileLoader($this->root->url());
$configCache = new ConfigCache();
$configFileLoader->setupCache($configCache);
->at($this->root->getChild('config'))
->setContent(file_get_contents($fileDir . 'B.ini.php'));
- $configFileLoader = new ConfigFileLoader($this->root->url(), $this->mode);
+ $configFileLoader = new ConfigFileLoader($this->root->url());
$configCache = new ConfigCache();
$configFileLoader->setupCache($configCache);
namespace Friendica\Test\src\Util;
+use Friendica\Core\Config\Cache\ConfigCache;
+use Friendica\Core\Config\Configuration;
use Friendica\Test\MockedTest;
use Friendica\Util\Profiler;
use Mockery\MockInterface;
*/
public function testSetUp()
{
- $profiler = new Profiler(true, true);
+ $configCache = \Mockery::mock(ConfigCache::class);
+ $configCache->shouldReceive('get')
+ ->withAnyArgs()
+ ->andReturn(true)
+ ->twice();
+ $profiler = new Profiler($configCache);
}
/**
*/
public function testSaveTimestamp($timestamp, $name, array $functions)
{
- $profiler = new Profiler(true, true);
+ $configCache = \Mockery::mock(ConfigCache::class);
+ $configCache->shouldReceive('get')
+ ->withAnyArgs()
+ ->andReturn(true)
+ ->twice();
+
+ $profiler = new Profiler($configCache);
foreach ($functions as $function) {
$profiler->saveTimestamp($timestamp, $name, $function);
*/
public function testReset($timestamp, $name, array $functions)
{
- $profiler = new Profiler(true, true);
+ $configCache = \Mockery::mock(ConfigCache::class);
+ $configCache->shouldReceive('get')
+ ->withAnyArgs()
+ ->andReturn(true)
+ ->twice();
+
+ $profiler = new Profiler($configCache);
$profiler->saveTimestamp($timestamp, $name);
$profiler->reset();
->shouldReceive('info')
->once();
- $profiler = new Profiler(true, true);
+ $configCache = \Mockery::mock(ConfigCache::class);
+ $configCache->shouldReceive('get')
+ ->withAnyArgs()
+ ->andReturn(true)
+ ->twice();
+
+ $profiler = new Profiler($configCache);
foreach ($data as $perf => $items) {
foreach ($items['functions'] as $function) {
*/
public function testEnableDisable()
{
- $profiler = new Profiler(true, false);
+ $configCache = \Mockery::mock(ConfigCache::class);
+ $configCache->shouldReceive('get')
+ ->with('system', 'profiler')
+ ->andReturn(true)
+ ->once();
+ $configCache->shouldReceive('get')
+ ->with('rendertime', 'callstack')
+ ->andReturn(false)
+ ->once();
+
+ $profiler = new Profiler($configCache);
$this->assertFalse($profiler->isRendertime());
$this->assertEmpty($profiler->getRendertimeString());
$profiler->saveTimestamp(time(), 'network', 'test1');
- $profiler->update(false, false);
+ $config = \Mockery::mock(Configuration::class);
+ $config->shouldReceive('get')
+ ->with('system', 'profiler')
+ ->andReturn(false)
+ ->once();
+ $config->shouldReceive('get')
+ ->with('rendertime', 'callstack')
+ ->andReturn(false)
+ ->once();
+
+ $profiler->update($config);
$this->assertFalse($profiler->isRendertime());
$this->assertEmpty($profiler->getRendertimeString());
- $profiler->update(true, true);
+ $config->shouldReceive('get')
+ ->with('system', 'profiler')
+ ->andReturn(true)
+ ->once();
+ $config->shouldReceive('get')
+ ->with('rendertime', 'callstack')
+ ->andReturn(true)
+ ->once();
+
+ $profiler->update($config);
$profiler->saveTimestamp(time(), 'database', 'test2');
projects / friendica.git / commitdiff