1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
|
<?php
use MediaWiki\Config\Config;
use MediaWiki\Config\ConfigException;
use MediaWiki\Config\ConfigFactory;
use MediaWiki\Config\GlobalVarConfig;
use MediaWiki\Config\HashConfig;
/**
* @covers \MediaWiki\Config\ConfigFactory
*/
class ConfigFactoryTest extends \MediaWikiIntegrationTestCase {
public function testRegister() {
$factory = new ConfigFactory();
$factory->register( 'unittest', 'GlobalVarConfig::newInstance' );
$this->assertInstanceOf( GlobalVarConfig::class, $factory->makeConfig( 'unittest' ) );
}
public function testRegisterInvalid() {
$factory = new ConfigFactory();
$this->expectException( InvalidArgumentException::class );
$factory->register( 'invalid', 'Invalid callback' );
}
public function testRegisterInvalidInstance() {
$factory = new ConfigFactory();
$this->expectException( InvalidArgumentException::class );
$factory->register( 'invalidInstance', (object)[] );
}
public function testRegisterInstance() {
$config = GlobalVarConfig::newInstance();
$factory = new ConfigFactory();
$factory->register( 'unittest', $config );
$this->assertSame( $config, $factory->makeConfig( 'unittest' ) );
}
public function testRegisterAgain() {
$factory = new ConfigFactory();
$factory->register( 'unittest', 'GlobalVarConfig::newInstance' );
$config1 = $factory->makeConfig( 'unittest' );
$factory->register( 'unittest', 'GlobalVarConfig::newInstance' );
$config2 = $factory->makeConfig( 'unittest' );
$this->assertNotSame( $config1, $config2 );
}
public function testSalvage() {
$oldFactory = new ConfigFactory();
$oldFactory->register( 'foo', 'GlobalVarConfig::newInstance' );
$oldFactory->register( 'bar', 'GlobalVarConfig::newInstance' );
$oldFactory->register( 'quux', 'GlobalVarConfig::newInstance' );
// instantiate two of the three defined configurations
$foo = $oldFactory->makeConfig( 'foo' );
$bar = $oldFactory->makeConfig( 'bar' );
$quux = $oldFactory->makeConfig( 'quux' );
// define new config instance
$newFactory = new ConfigFactory();
$newFactory->register( 'foo', 'GlobalVarConfig::newInstance' );
$newFactory->register( 'bar', static function () {
return new HashConfig();
} );
// "foo" and "quux" are defined in the old and the new factory.
// The old factory has instances for "foo" and "bar", but not "quux".
$newFactory->salvage( $oldFactory );
$newFoo = $newFactory->makeConfig( 'foo' );
$this->assertSame( $foo, $newFoo, 'existing instance should be salvaged' );
$newBar = $newFactory->makeConfig( 'bar' );
$this->assertNotSame( $bar, $newBar, 'don\'t salvage if callbacks differ' );
// the new factory doesn't have quux defined, so the quux instance should not be salvaged
$this->expectException( ConfigException::class );
$newFactory->makeConfig( 'quux' );
}
public function testGetConfigNames() {
$factory = new ConfigFactory();
$factory->register( 'foo', 'GlobalVarConfig::newInstance' );
$factory->register( 'bar', new HashConfig() );
$this->assertEquals( [ 'foo', 'bar' ], $factory->getConfigNames() );
}
public function testMakeConfigWithCallback() {
$factory = new ConfigFactory();
$factory->register( 'unittest', 'GlobalVarConfig::newInstance' );
$conf = $factory->makeConfig( 'unittest' );
$this->assertInstanceOf( Config::class, $conf );
$this->assertSame( $conf, $factory->makeConfig( 'unittest' ) );
}
public function testMakeConfigWithObject() {
$factory = new ConfigFactory();
$conf = new HashConfig();
$factory->register( 'test', $conf );
$this->assertSame( $conf, $factory->makeConfig( 'test' ) );
}
public function testMakeConfigFallback() {
$factory = new ConfigFactory();
$factory->register( '*', 'GlobalVarConfig::newInstance' );
$conf = $factory->makeConfig( 'unittest' );
$this->assertInstanceOf( Config::class, $conf );
}
public function testMakeConfigWithNoBuilders() {
$factory = new ConfigFactory();
$this->expectException( ConfigException::class );
$factory->makeConfig( 'nobuilderregistered' );
}
public function testMakeConfigWithInvalidCallback() {
$factory = new ConfigFactory();
$factory->register( 'unittest', static function () {
return true; // Not a Config object
} );
$this->expectException( UnexpectedValueException::class );
$factory->makeConfig( 'unittest' );
}
public function testGetDefaultInstance() {
// NOTE: the global config factory returned here has been overwritten
// for operation in test mode. It may not reflect LocalSettings.
$factory = $this->getServiceContainer()->getConfigFactory();
$this->assertInstanceOf( Config::class, $factory->makeConfig( 'main' ) );
}
}
|
