nextcloud / server

tests/redis-cluster.config.php

Indentation +16 added lines, -16 removed lines

@@ -4,20 +4,20 @@
  * SPDX-License-Identifier: AGPL-3.0-or-later
  */
 $CONFIG = [
-	'memcache.local' => '\\OC\\Memcache\\Redis',
-	'memcache.distributed' => '\\OC\\Memcache\\Redis',
-	'memcache.locking' => '\\OC\\Memcache\\Redis',
-	'redis.cluster' => [
-		'seeds' => [ // provide some/all of the cluster servers to bootstrap discovery, port required
-			'cache-cluster:7000',
-			'cache-cluster:7001',
-			'cache-cluster:7002',
-			'cache-cluster:7003',
-			'cache-cluster:7004',
-			'cache-cluster:7005'
-		],
-		'timeout' => 0.0,
-		'read_timeout' => 0.0,
-		'failover_mode' => \RedisCluster::FAILOVER_ERROR
-	],
+    'memcache.local' => '\\OC\\Memcache\\Redis',
+    'memcache.distributed' => '\\OC\\Memcache\\Redis',
+    'memcache.locking' => '\\OC\\Memcache\\Redis',
+    'redis.cluster' => [
+        'seeds' => [ // provide some/all of the cluster servers to bootstrap discovery, port required
+            'cache-cluster:7000',
+            'cache-cluster:7001',
+            'cache-cluster:7002',
+            'cache-cluster:7003',
+            'cache-cluster:7004',
+            'cache-cluster:7005'
+        ],
+        'timeout' => 0.0,
+        'read_timeout' => 0.0,
+        'failover_mode' => \RedisCluster::FAILOVER_ERROR
+    ],
 ];

tests/preseed-config.php

Indentation +95 added lines, -95 removed lines

@@ -5,112 +5,112 @@
  * SPDX-License-Identifier: AGPL-3.0-only
  */
 $CONFIG = [
-	'appstoreenabled' => false,
-	'apps_paths' => [
-		[
-			'path' => OC::$SERVERROOT . '/apps',
-			'url' => '/apps',
-			'writable' => true,
-		],
-	],
+    'appstoreenabled' => false,
+    'apps_paths' => [
+        [
+            'path' => OC::$SERVERROOT . '/apps',
+            'url' => '/apps',
+            'writable' => true,
+        ],
+    ],
 ];
 
 if (is_dir(OC::$SERVERROOT . '/apps2')) {
-	$CONFIG['apps_paths'][] = [
-		'path' => OC::$SERVERROOT . '/apps2',
-		'url' => '/apps2',
-		'writable' => false,
-	];
+    $CONFIG['apps_paths'][] = [
+        'path' => OC::$SERVERROOT . '/apps2',
+        'url' => '/apps2',
+        'writable' => false,
+    ];
 }
 
 if (getenv('OBJECT_STORE') === 's3') {
-	$CONFIG['objectstore'] = [
-		'class' => 'OC\\Files\\ObjectStore\\S3',
-		'arguments' => [
-			'bucket' => 'nextcloud',
-			'autocreate' => true,
-			'key' => getenv('OBJECT_STORE_KEY') ?: 'nextcloud',
-			'secret' => getenv('OBJECT_STORE_SECRET') ?: 'nextcloud',
-			'hostname' => getenv('OBJECT_STORE_HOST') ?: 'localhost',
-			'port' => 9000,
-			'use_ssl' => false,
-			// required for some non amazon s3 implementations
-			'use_path_style' => true
-		]
-	];
+    $CONFIG['objectstore'] = [
+        'class' => 'OC\\Files\\ObjectStore\\S3',
+        'arguments' => [
+            'bucket' => 'nextcloud',
+            'autocreate' => true,
+            'key' => getenv('OBJECT_STORE_KEY') ?: 'nextcloud',
+            'secret' => getenv('OBJECT_STORE_SECRET') ?: 'nextcloud',
+            'hostname' => getenv('OBJECT_STORE_HOST') ?: 'localhost',
+            'port' => 9000,
+            'use_ssl' => false,
+            // required for some non amazon s3 implementations
+            'use_path_style' => true
+        ]
+    ];
 } elseif (getenv('OBJECT_STORE') === 's3-multibucket') {
-	$CONFIG['objectstore_multibucket'] = [
-		'class' => 'OC\\Files\\ObjectStore\\S3',
-		'arguments' => [
-			'bucket' => 'nextcloud',
-			'autocreate' => true,
-			'key' => getenv('OBJECT_STORE_KEY') ?: 'nextcloud',
-			'secret' => getenv('OBJECT_STORE_SECRET') ?: 'nextcloud',
-			'hostname' => getenv('OBJECT_STORE_HOST') ?: 'localhost',
-			'port' => 9000,
-			'use_ssl' => false,
-			// required for some non amazon s3 implementations
-			'use_path_style' => true
-		]
-	];
+    $CONFIG['objectstore_multibucket'] = [
+        'class' => 'OC\\Files\\ObjectStore\\S3',
+        'arguments' => [
+            'bucket' => 'nextcloud',
+            'autocreate' => true,
+            'key' => getenv('OBJECT_STORE_KEY') ?: 'nextcloud',
+            'secret' => getenv('OBJECT_STORE_SECRET') ?: 'nextcloud',
+            'hostname' => getenv('OBJECT_STORE_HOST') ?: 'localhost',
+            'port' => 9000,
+            'use_ssl' => false,
+            // required for some non amazon s3 implementations
+            'use_path_style' => true
+        ]
+    ];
 } elseif (getenv('OBJECT_STORE') === 'azure') {
-	$CONFIG['objectstore'] = [
-		'class' => 'OC\\Files\\ObjectStore\\Azure',
-		'arguments' => [
-			'container' => 'test',
-			'account_name' => getenv('OBJECT_STORE_KEY') ?: 'devstoreaccount1',
-			'account_key' => getenv('OBJECT_STORE_SECRET') ?: 'Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==',
-			'endpoint' => 'http://' . (getenv('OBJECT_STORE_HOST') ?: 'localhost') . ':10000/' . (getenv('OBJECT_STORE_KEY') ?: 'devstoreaccount1'),
-			'autocreate' => true
-		]
-	];
+    $CONFIG['objectstore'] = [
+        'class' => 'OC\\Files\\ObjectStore\\Azure',
+        'arguments' => [
+            'container' => 'test',
+            'account_name' => getenv('OBJECT_STORE_KEY') ?: 'devstoreaccount1',
+            'account_key' => getenv('OBJECT_STORE_SECRET') ?: 'Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==',
+            'endpoint' => 'http://' . (getenv('OBJECT_STORE_HOST') ?: 'localhost') . ':10000/' . (getenv('OBJECT_STORE_KEY') ?: 'devstoreaccount1'),
+            'autocreate' => true
+        ]
+    ];
 } elseif (getenv('OBJECT_STORE') === 'swift') {
-	$swiftHost = getenv('OBJECT_STORE_HOST') ?: 'localhost:5000';
+    $swiftHost = getenv('OBJECT_STORE_HOST') ?: 'localhost:5000';
 
-	$CONFIG['objectstore'] = [
-		'class' => 'OC\\Files\\ObjectStore\\Swift',
-		'arguments' => [
-			'autocreate' => true,
-			'user' => [
-				'name' => getenv('OBJECT_STORE_KEY') ?: 'swift',
-				'password' => getenv('OBJECT_STORE_SECRET') ?: 'swift',
-				'domain' => [
-					'name' => 'Default',
-				],
-			],
-			'scope' => [
-				'project' => [
-					'name' => 'service',
-					'domain' => [
-						'name' => 'Default',
-					],
-				],
-			],
-			'serviceName' => 'service',
-			'region' => 'RegionOne',
-			'url' => "http://$swiftHost/v3",
-			'bucket' => 'nextcloud',
-		]
-	];
+    $CONFIG['objectstore'] = [
+        'class' => 'OC\\Files\\ObjectStore\\Swift',
+        'arguments' => [
+            'autocreate' => true,
+            'user' => [
+                'name' => getenv('OBJECT_STORE_KEY') ?: 'swift',
+                'password' => getenv('OBJECT_STORE_SECRET') ?: 'swift',
+                'domain' => [
+                    'name' => 'Default',
+                ],
+            ],
+            'scope' => [
+                'project' => [
+                    'name' => 'service',
+                    'domain' => [
+                        'name' => 'Default',
+                    ],
+                ],
+            ],
+            'serviceName' => 'service',
+            'region' => 'RegionOne',
+            'url' => "http://$swiftHost/v3",
+            'bucket' => 'nextcloud',
+        ]
+    ];
 }
 
 if (getenv('SHARDING') == '1') {
-	$CONFIG['dbsharding'] = [
-		'filecache' => [
-			'shards' => [
-				[
-					'port' => 5001,
-				],
-				[
-					'port' => 5002,
-				],
-				[
-					'port' => 5003,
-				],
-				[
-					'port' => 5004,
-				],
-			]
-		]
-	];
+    $CONFIG['dbsharding'] = [
+        'filecache' => [
+            'shards' => [
+                [
+                    'port' => 5001,
+                ],
+                [
+                    'port' => 5002,
+                ],
+                [
+                    'port' => 5003,
+                ],
+                [
+                    'port' => 5004,
+                ],
+            ]
+        ]
+    ];
 }

tests/lib/Accounts/AccountPropertyCollectionTest.php

Indentation +172 added lines, -172 removed lines

@@ -17,176 +17,176 @@
 use Test\TestCase;
 
 class AccountPropertyCollectionTest extends TestCase {
-	/** @var IAccountPropertyCollection */
-	protected $collection;
-
-	protected const COLLECTION_NAME = 'my_multivalue_property';
-
-	public function setUp(): void {
-		parent::setUp();
-
-		$this->collection = new AccountPropertyCollection(self::COLLECTION_NAME);
-	}
-
-	/**
-	 * @return IAccountProperty|MockObject
-	 */
-	protected function makePropertyMock(string $propertyName): MockObject {
-		$mock = $this->createMock(IAccountProperty::class);
-		$mock->expects($this->any())
-			->method('getName')
-			->willReturn($propertyName);
-
-		return $mock;
-	}
-
-	public function testSetAndGetProperties(): void {
-		$propsBefore = $this->collection->getProperties();
-		$this->assertIsArray($propsBefore);
-		$this->assertEmpty($propsBefore);
-
-		$props = [
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$this->makePropertyMock(self::COLLECTION_NAME),
-		];
-
-		$this->collection->setProperties($props);
-		$propsAfter = $this->collection->getProperties();
-		$this->assertIsArray($propsAfter);
-		$this->assertCount(count($props), $propsAfter);
-	}
-
-	public function testSetPropertiesMixedInvalid(): void {
-		$props = [
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$this->makePropertyMock('sneaky_property'),
-			$this->makePropertyMock(self::COLLECTION_NAME),
-		];
-
-		$this->expectException(InvalidArgumentException::class);
-		$this->collection->setProperties($props);
-	}
-
-	public function testAddProperty(): void {
-		$props = [
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$this->makePropertyMock(self::COLLECTION_NAME),
-		];
-		$this->collection->setProperties($props);
-
-		$additionalProperty = $this->makePropertyMock(self::COLLECTION_NAME);
-		$this->collection->addProperty($additionalProperty);
-
-		$propsAfter = $this->collection->getProperties();
-		$this->assertCount(count($props) + 1, $propsAfter);
-		$this->assertNotFalse(array_search($additionalProperty, $propsAfter, true));
-	}
-
-	public function testAddPropertyInvalid(): void {
-		$props = [
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$this->makePropertyMock(self::COLLECTION_NAME),
-		];
-		$this->collection->setProperties($props);
-
-		$additionalProperty = $this->makePropertyMock('sneaky_property');
-		$exceptionThrown = false;
-		try {
-			$this->collection->addProperty($additionalProperty);
-		} catch (\InvalidArgumentException $e) {
-			$exceptionThrown = true;
-		} finally {
-			$propsAfter = $this->collection->getProperties();
-			$this->assertCount(count($props), $propsAfter);
-			$this->assertFalse(array_search($additionalProperty, $propsAfter, true));
-			$this->assertTrue($exceptionThrown);
-		}
-	}
-
-	public function testRemoveProperty(): void {
-		$additionalProperty = $this->makePropertyMock(self::COLLECTION_NAME);
-		$props = [
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$additionalProperty,
-			$this->makePropertyMock(self::COLLECTION_NAME),
-		];
-		$this->collection->setProperties($props);
-
-		$propsBefore = $this->collection->getProperties();
-		$this->collection->removeProperty($additionalProperty);
-		$propsAfter = $this->collection->getProperties();
-
-		$this->assertTrue(count($propsBefore) > count($propsAfter));
-		$this->assertCount(count($propsBefore) - 1, $propsAfter);
-		$this->assertFalse(array_search($additionalProperty, $propsAfter, true));
-	}
-
-	public function testRemovePropertyNotFound(): void {
-		$additionalProperty = $this->makePropertyMock(self::COLLECTION_NAME);
-		$props = [
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$this->makePropertyMock(self::COLLECTION_NAME),
-		];
-		$this->collection->setProperties($props);
-
-		$propsBefore = $this->collection->getProperties();
-		$this->collection->removeProperty($additionalProperty);
-		$propsAfter = $this->collection->getProperties();
-
-		// no errors, gently
-		$this->assertCount(count($propsBefore), $propsAfter);
-	}
-
-	public function testRemovePropertyByValue(): void {
-		$additionalProperty = $this->makePropertyMock(self::COLLECTION_NAME);
-		$additionalProperty->expects($this->any())
-			->method('getValue')
-			->willReturn('Lorem ipsum');
-
-		$additionalPropertyTwo = clone $additionalProperty;
-
-		$props = [
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$additionalProperty,
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$additionalPropertyTwo
-		];
-		$this->collection->setProperties($props);
-
-		$propsBefore = $this->collection->getProperties();
-		$this->collection->removePropertyByValue('Lorem ipsum');
-		$propsAfter = $this->collection->getProperties();
-
-		$this->assertTrue(count($propsBefore) > count($propsAfter));
-		$this->assertCount(count($propsBefore) - 2, $propsAfter);
-		$this->assertFalse(array_search($additionalProperty, $propsAfter, true));
-		$this->assertFalse(array_search($additionalPropertyTwo, $propsAfter, true));
-	}
-
-	public function testRemovePropertyByValueNotFound(): void {
-		$additionalProperty = $this->makePropertyMock(self::COLLECTION_NAME);
-		$additionalProperty->expects($this->any())
-			->method('getValue')
-			->willReturn('Lorem ipsum');
-
-		$props = [
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$this->makePropertyMock(self::COLLECTION_NAME),
-			$this->makePropertyMock(self::COLLECTION_NAME),
-		];
-		$this->collection->setProperties($props);
-
-		$propsBefore = $this->collection->getProperties();
-		$this->collection->removePropertyByValue('Lorem ipsum');
-		$propsAfter = $this->collection->getProperties();
-
-		// no errors, gently
-		$this->assertCount(count($propsBefore), $propsAfter);
-	}
+    /** @var IAccountPropertyCollection */
+    protected $collection;
+
+    protected const COLLECTION_NAME = 'my_multivalue_property';
+
+    public function setUp(): void {
+        parent::setUp();
+
+        $this->collection = new AccountPropertyCollection(self::COLLECTION_NAME);
+    }
+
+    /**
+     * @return IAccountProperty|MockObject
+     */
+    protected function makePropertyMock(string $propertyName): MockObject {
+        $mock = $this->createMock(IAccountProperty::class);
+        $mock->expects($this->any())
+            ->method('getName')
+            ->willReturn($propertyName);
+
+        return $mock;
+    }
+
+    public function testSetAndGetProperties(): void {
+        $propsBefore = $this->collection->getProperties();
+        $this->assertIsArray($propsBefore);
+        $this->assertEmpty($propsBefore);
+
+        $props = [
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $this->makePropertyMock(self::COLLECTION_NAME),
+        ];
+
+        $this->collection->setProperties($props);
+        $propsAfter = $this->collection->getProperties();
+        $this->assertIsArray($propsAfter);
+        $this->assertCount(count($props), $propsAfter);
+    }
+
+    public function testSetPropertiesMixedInvalid(): void {
+        $props = [
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $this->makePropertyMock('sneaky_property'),
+            $this->makePropertyMock(self::COLLECTION_NAME),
+        ];
+
+        $this->expectException(InvalidArgumentException::class);
+        $this->collection->setProperties($props);
+    }
+
+    public function testAddProperty(): void {
+        $props = [
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $this->makePropertyMock(self::COLLECTION_NAME),
+        ];
+        $this->collection->setProperties($props);
+
+        $additionalProperty = $this->makePropertyMock(self::COLLECTION_NAME);
+        $this->collection->addProperty($additionalProperty);
+
+        $propsAfter = $this->collection->getProperties();
+        $this->assertCount(count($props) + 1, $propsAfter);
+        $this->assertNotFalse(array_search($additionalProperty, $propsAfter, true));
+    }
+
+    public function testAddPropertyInvalid(): void {
+        $props = [
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $this->makePropertyMock(self::COLLECTION_NAME),
+        ];
+        $this->collection->setProperties($props);
+
+        $additionalProperty = $this->makePropertyMock('sneaky_property');
+        $exceptionThrown = false;
+        try {
+            $this->collection->addProperty($additionalProperty);
+        } catch (\InvalidArgumentException $e) {
+            $exceptionThrown = true;
+        } finally {
+            $propsAfter = $this->collection->getProperties();
+            $this->assertCount(count($props), $propsAfter);
+            $this->assertFalse(array_search($additionalProperty, $propsAfter, true));
+            $this->assertTrue($exceptionThrown);
+        }
+    }
+
+    public function testRemoveProperty(): void {
+        $additionalProperty = $this->makePropertyMock(self::COLLECTION_NAME);
+        $props = [
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $additionalProperty,
+            $this->makePropertyMock(self::COLLECTION_NAME),
+        ];
+        $this->collection->setProperties($props);
+
+        $propsBefore = $this->collection->getProperties();
+        $this->collection->removeProperty($additionalProperty);
+        $propsAfter = $this->collection->getProperties();
+
+        $this->assertTrue(count($propsBefore) > count($propsAfter));
+        $this->assertCount(count($propsBefore) - 1, $propsAfter);
+        $this->assertFalse(array_search($additionalProperty, $propsAfter, true));
+    }
+
+    public function testRemovePropertyNotFound(): void {
+        $additionalProperty = $this->makePropertyMock(self::COLLECTION_NAME);
+        $props = [
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $this->makePropertyMock(self::COLLECTION_NAME),
+        ];
+        $this->collection->setProperties($props);
+
+        $propsBefore = $this->collection->getProperties();
+        $this->collection->removeProperty($additionalProperty);
+        $propsAfter = $this->collection->getProperties();
+
+        // no errors, gently
+        $this->assertCount(count($propsBefore), $propsAfter);
+    }
+
+    public function testRemovePropertyByValue(): void {
+        $additionalProperty = $this->makePropertyMock(self::COLLECTION_NAME);
+        $additionalProperty->expects($this->any())
+            ->method('getValue')
+            ->willReturn('Lorem ipsum');
+
+        $additionalPropertyTwo = clone $additionalProperty;
+
+        $props = [
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $additionalProperty,
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $additionalPropertyTwo
+        ];
+        $this->collection->setProperties($props);
+
+        $propsBefore = $this->collection->getProperties();
+        $this->collection->removePropertyByValue('Lorem ipsum');
+        $propsAfter = $this->collection->getProperties();
+
+        $this->assertTrue(count($propsBefore) > count($propsAfter));
+        $this->assertCount(count($propsBefore) - 2, $propsAfter);
+        $this->assertFalse(array_search($additionalProperty, $propsAfter, true));
+        $this->assertFalse(array_search($additionalPropertyTwo, $propsAfter, true));
+    }
+
+    public function testRemovePropertyByValueNotFound(): void {
+        $additionalProperty = $this->makePropertyMock(self::COLLECTION_NAME);
+        $additionalProperty->expects($this->any())
+            ->method('getValue')
+            ->willReturn('Lorem ipsum');
+
+        $props = [
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $this->makePropertyMock(self::COLLECTION_NAME),
+            $this->makePropertyMock(self::COLLECTION_NAME),
+        ];
+        $this->collection->setProperties($props);
+
+        $propsBefore = $this->collection->getProperties();
+        $this->collection->removePropertyByValue('Lorem ipsum');
+        $propsAfter = $this->collection->getProperties();
+
+        // no errors, gently
+        $this->assertCount(count($propsBefore), $propsAfter);
+    }
 }

tests/lib/Notification/DummyApp.php

Indentation +23 added lines, -23 removed lines

@@ -12,29 +12,29 @@
 use OCP\Notification\INotification;
 
 class DummyApp implements IApp {
-	/**
-	 * @param INotification $notification
-	 * @throws \InvalidArgumentException When the notification is not valid
-	 * @since 9.0.0
-	 */
-	public function notify(INotification $notification): void {
-		// TODO: Implement notify() method.
-	}
+    /**
+     * @param INotification $notification
+     * @throws \InvalidArgumentException When the notification is not valid
+     * @since 9.0.0
+     */
+    public function notify(INotification $notification): void {
+        // TODO: Implement notify() method.
+    }
 
-	/**
-	 * @param INotification $notification
-	 * @since 9.0.0
-	 */
-	public function markProcessed(INotification $notification): void {
-		// TODO: Implement markProcessed() method.
-	}
+    /**
+     * @param INotification $notification
+     * @since 9.0.0
+     */
+    public function markProcessed(INotification $notification): void {
+        // TODO: Implement markProcessed() method.
+    }
 
-	/**
-	 * @param INotification $notification
-	 * @return int
-	 * @since 9.0.0
-	 */
-	public function getCount(INotification $notification): int {
-		// TODO: Implement getCount() method.
-	}
+    /**
+     * @param INotification $notification
+     * @return int
+     * @since 9.0.0
+     */
+    public function getCount(INotification $notification): int {
+        // TODO: Implement getCount() method.
+    }
 }

tests/lib/Notification/DummyNotifier.php

Indentation +29 added lines, -29 removed lines

@@ -13,35 +13,35 @@
 use OCP\Notification\INotifier;
 
 class DummyNotifier implements INotifier {
-	/**
-	 * Identifier of the notifier, only use [a-z0-9_]
-	 *
-	 * @return string
-	 * @since 17.0.0
-	 */
-	public function getID(): string {
-		// TODO: Implement getID() method.
-	}
+    /**
+     * Identifier of the notifier, only use [a-z0-9_]
+     *
+     * @return string
+     * @since 17.0.0
+     */
+    public function getID(): string {
+        // TODO: Implement getID() method.
+    }
 
-	/**
-	 * Human readable name describing the notifier
-	 *
-	 * @return string
-	 * @since 17.0.0
-	 */
-	public function getName(): string {
-		// TODO: Implement getName() method.
-	}
+    /**
+     * Human readable name describing the notifier
+     *
+     * @return string
+     * @since 17.0.0
+     */
+    public function getName(): string {
+        // TODO: Implement getName() method.
+    }
 
-	/**
-	 * @param INotification $notification
-	 * @param string $languageCode The code of the language that should be used to prepare the notification
-	 * @return INotification
-	 * @throws \InvalidArgumentException When the notification was not prepared by a notifier
-	 * @throws AlreadyProcessedException When the notification is not needed anymore and should be deleted
-	 * @since 9.0.0
-	 */
-	public function prepare(INotification $notification, string $languageCode): INotification {
-		// TODO: Implement prepare() method.
-	}
+    /**
+     * @param INotification $notification
+     * @param string $languageCode The code of the language that should be used to prepare the notification
+     * @return INotification
+     * @throws \InvalidArgumentException When the notification was not prepared by a notifier
+     * @throws AlreadyProcessedException When the notification is not needed anymore and should be deleted
+     * @since 9.0.0
+     */
+    public function prepare(INotification $notification, string $languageCode): INotification {
+        // TODO: Implement prepare() method.
+    }
 }

tests/lib/Lockdown/LockdownManagerTest.php

Indentation +30 added lines, -30 removed lines

@@ -13,34 +13,34 @@
 use Test\TestCase;
 
 class LockdownManagerTest extends TestCase {
-	private $sessionCallback;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->sessionCallback = function () {
-			return $this->createMock(ISession::class);
-		};
-	}
-
-	public function testCanAccessFilesystemDisabled(): void {
-		$manager = new LockdownManager($this->sessionCallback);
-		$this->assertTrue($manager->canAccessFilesystem());
-	}
-
-	public function testCanAccessFilesystemAllowed(): void {
-		$token = new PublicKeyToken();
-		$token->setScope([IToken::SCOPE_FILESYSTEM => true]);
-		$manager = new LockdownManager($this->sessionCallback);
-		$manager->setToken($token);
-		$this->assertTrue($manager->canAccessFilesystem());
-	}
-
-	public function testCanAccessFilesystemNotAllowed(): void {
-		$token = new PublicKeyToken();
-		$token->setScope([IToken::SCOPE_FILESYSTEM => false]);
-		$manager = new LockdownManager($this->sessionCallback);
-		$manager->setToken($token);
-		$this->assertFalse($manager->canAccessFilesystem());
-	}
+    private $sessionCallback;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->sessionCallback = function () {
+            return $this->createMock(ISession::class);
+        };
+    }
+
+    public function testCanAccessFilesystemDisabled(): void {
+        $manager = new LockdownManager($this->sessionCallback);
+        $this->assertTrue($manager->canAccessFilesystem());
+    }
+
+    public function testCanAccessFilesystemAllowed(): void {
+        $token = new PublicKeyToken();
+        $token->setScope([IToken::SCOPE_FILESYSTEM => true]);
+        $manager = new LockdownManager($this->sessionCallback);
+        $manager->setToken($token);
+        $this->assertTrue($manager->canAccessFilesystem());
+    }
+
+    public function testCanAccessFilesystemNotAllowed(): void {
+        $token = new PublicKeyToken();
+        $token->setScope([IToken::SCOPE_FILESYSTEM => false]);
+        $manager = new LockdownManager($this->sessionCallback);
+        $manager->setToken($token);
+        $this->assertFalse($manager->canAccessFilesystem());
+    }
 }

tests/lib/Lockdown/Filesystem/NullStorageTest.php

Indentation +154 added lines, -154 removed lines

@@ -15,214 +15,214 @@
 use Test\TestCase;
 
 class NullStorageTest extends TestCase {
-	/** @var NullStorage */
-	private $storage;
+    /** @var NullStorage */
+    private $storage;
 
-	protected function setUp(): void {
-		parent::setUp();
+    protected function setUp(): void {
+        parent::setUp();
 
-		$this->storage = new NullStorage([]);
-	}
+        $this->storage = new NullStorage([]);
+    }
 
-	public function testGetId(): void {
-		$this->assertSame('null', $this->storage->getId());
-	}
+    public function testGetId(): void {
+        $this->assertSame('null', $this->storage->getId());
+    }
 
-	public function testMkdir(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testMkdir(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->mkdir('foo');
-	}
+        $this->storage->mkdir('foo');
+    }
 
-	public function testRmdir(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testRmdir(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->rmdir('foo');
-	}
+        $this->storage->rmdir('foo');
+    }
 
-	public function testOpendir(): void {
-		$this->assertInstanceOf(IteratorDirectory::class, $this->storage->opendir('foo'));
-	}
+    public function testOpendir(): void {
+        $this->assertInstanceOf(IteratorDirectory::class, $this->storage->opendir('foo'));
+    }
 
-	public function testIs_dir(): void {
-		$this->assertTrue($this->storage->is_dir(''));
-		$this->assertFalse($this->storage->is_dir('foo'));
-	}
+    public function testIs_dir(): void {
+        $this->assertTrue($this->storage->is_dir(''));
+        $this->assertFalse($this->storage->is_dir('foo'));
+    }
 
-	public function testIs_file(): void {
-		$this->assertFalse($this->storage->is_file('foo'));
-	}
+    public function testIs_file(): void {
+        $this->assertFalse($this->storage->is_file('foo'));
+    }
 
-	public function testStat(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testStat(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->stat('foo');
-	}
+        $this->storage->stat('foo');
+    }
 
-	public function testFiletype(): void {
-		$this->assertSame('dir', $this->storage->filetype(''));
-		$this->assertFalse($this->storage->filetype('foo'));
-	}
+    public function testFiletype(): void {
+        $this->assertSame('dir', $this->storage->filetype(''));
+        $this->assertFalse($this->storage->filetype('foo'));
+    }
 
-	public function testFilesize(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testFilesize(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->filesize('foo');
-	}
+        $this->storage->filesize('foo');
+    }
 
-	public function testIsCreatable(): void {
-		$this->assertFalse($this->storage->isCreatable('foo'));
-	}
+    public function testIsCreatable(): void {
+        $this->assertFalse($this->storage->isCreatable('foo'));
+    }
 
-	public function testIsReadable(): void {
-		$this->assertTrue($this->storage->isReadable(''));
-		$this->assertFalse($this->storage->isReadable('foo'));
-	}
+    public function testIsReadable(): void {
+        $this->assertTrue($this->storage->isReadable(''));
+        $this->assertFalse($this->storage->isReadable('foo'));
+    }
 
-	public function testIsUpdatable(): void {
-		$this->assertFalse($this->storage->isUpdatable('foo'));
-	}
+    public function testIsUpdatable(): void {
+        $this->assertFalse($this->storage->isUpdatable('foo'));
+    }
 
-	public function testIsDeletable(): void {
-		$this->assertFalse($this->storage->isDeletable('foo'));
-	}
+    public function testIsDeletable(): void {
+        $this->assertFalse($this->storage->isDeletable('foo'));
+    }
 
-	public function testIsSharable(): void {
-		$this->assertFalse($this->storage->isSharable('foo'));
-	}
+    public function testIsSharable(): void {
+        $this->assertFalse($this->storage->isSharable('foo'));
+    }
 
-	public function testGetPermissions(): void {
-		$this->assertEquals(0, $this->storage->getPermissions('foo'));
-	}
+    public function testGetPermissions(): void {
+        $this->assertEquals(0, $this->storage->getPermissions('foo'));
+    }
 
-	public function testFile_exists(): void {
-		$this->assertTrue($this->storage->file_exists(''));
-		$this->assertFalse($this->storage->file_exists('foo'));
-	}
+    public function testFile_exists(): void {
+        $this->assertTrue($this->storage->file_exists(''));
+        $this->assertFalse($this->storage->file_exists('foo'));
+    }
 
-	public function testFilemtime(): void {
-		$this->assertFalse($this->storage->filemtime('foo'));
-	}
+    public function testFilemtime(): void {
+        $this->assertFalse($this->storage->filemtime('foo'));
+    }
 
-	public function testFile_get_contents(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testFile_get_contents(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->file_get_contents('foo');
-	}
+        $this->storage->file_get_contents('foo');
+    }
 
-	public function testFile_put_contents(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testFile_put_contents(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->file_put_contents('foo', 'bar');
-	}
+        $this->storage->file_put_contents('foo', 'bar');
+    }
 
-	public function testUnlink(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testUnlink(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->unlink('foo');
-	}
+        $this->storage->unlink('foo');
+    }
 
-	public function testRename(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testRename(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->rename('foo', 'bar');
-	}
+        $this->storage->rename('foo', 'bar');
+    }
 
-	public function testCopy(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testCopy(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->copy('foo', 'bar');
-	}
+        $this->storage->copy('foo', 'bar');
+    }
 
-	public function testFopen(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testFopen(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->fopen('foo', 'R');
-	}
+        $this->storage->fopen('foo', 'R');
+    }
 
-	public function testGetMimeType(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testGetMimeType(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->getMimeType('foo');
-	}
+        $this->storage->getMimeType('foo');
+    }
 
-	public function testHash(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testHash(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->hash('md5', 'foo', true);
-	}
+        $this->storage->hash('md5', 'foo', true);
+    }
 
-	public function testFree_space(): void {
-		$this->assertSame(FileInfo::SPACE_UNKNOWN, $this->storage->free_space('foo'));
-	}
+    public function testFree_space(): void {
+        $this->assertSame(FileInfo::SPACE_UNKNOWN, $this->storage->free_space('foo'));
+    }
 
-	public function testTouch(): void {
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+    public function testTouch(): void {
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->touch('foo');
-	}
+        $this->storage->touch('foo');
+    }
 
-	public function testGetLocalFile(): void {
-		$this->assertFalse($this->storage->getLocalFile('foo'));
-	}
+    public function testGetLocalFile(): void {
+        $this->assertFalse($this->storage->getLocalFile('foo'));
+    }
 
-	public function testHasUpdated(): void {
-		$this->assertFalse($this->storage->hasUpdated('foo', 42));
-	}
+    public function testHasUpdated(): void {
+        $this->assertFalse($this->storage->hasUpdated('foo', 42));
+    }
 
-	public function testGetETag(): void {
-		$this->assertSame('', $this->storage->getETag('foo'));
-	}
+    public function testGetETag(): void {
+        $this->assertSame('', $this->storage->getETag('foo'));
+    }
 
-	public function testIsLocal(): void {
-		$this->assertFalse($this->storage->isLocal());
-	}
+    public function testIsLocal(): void {
+        $this->assertFalse($this->storage->isLocal());
+    }
 
-	public function testGetDirectDownload(): void {
-		$this->assertFalse($this->storage->getDirectDownload('foo'));
-	}
+    public function testGetDirectDownload(): void {
+        $this->assertFalse($this->storage->getDirectDownload('foo'));
+    }
 
-	public function testCopyFromStorage(): void {
-		$sourceStorage = $this->createMock(IStorage::class);
+    public function testCopyFromStorage(): void {
+        $sourceStorage = $this->createMock(IStorage::class);
 
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->copyFromStorage($sourceStorage, 'foo', 'bar');
-	}
+        $this->storage->copyFromStorage($sourceStorage, 'foo', 'bar');
+    }
 
-	public function testMoveFromStorage(): void {
-		$sourceStorage = $this->createMock(IStorage::class);
+    public function testMoveFromStorage(): void {
+        $sourceStorage = $this->createMock(IStorage::class);
 
-		$this->expectException(ForbiddenException::class);
-		$this->expectExceptionMessage('This request is not allowed to access the filesystem');
+        $this->expectException(ForbiddenException::class);
+        $this->expectExceptionMessage('This request is not allowed to access the filesystem');
 
-		$this->storage->moveFromStorage($sourceStorage, 'foo', 'bar');
-	}
+        $this->storage->moveFromStorage($sourceStorage, 'foo', 'bar');
+    }
 
-	public function testTest() {
-		$this->assertTrue($this->storage->test());
-		return true;
-	}
+    public function testTest() {
+        $this->assertTrue($this->storage->test());
+        return true;
+    }
 
-	public function testGetOwner(): void {
-		$this->assertFalse($this->storage->getOwner('foo'));
-	}
+    public function testGetOwner(): void {
+        $this->assertFalse($this->storage->getOwner('foo'));
+    }
 
-	public function testGetCache(): void {
-		$this->assertInstanceOf(NullCache::class, $this->storage->getCache('foo'));
-	}
+    public function testGetCache(): void {
+        $this->assertInstanceOf(NullCache::class, $this->storage->getCache('foo'));
+    }
 }

tests/lib/AppScriptSortTest.php

Indentation +102 added lines, -102 removed lines

@@ -18,106 +18,106 @@
  * @group DB
  */
 class AppScriptSortTest extends \Test\TestCase {
-	private $logger;
-
-	protected function setUp(): void {
-		$this->logger = $this->getMockBuilder(LoggerInterface::class)
-			->disableOriginalConstructor()
-			->getMock();
-
-		parent::setUp();
-	}
-
-	public function testSort(): void {
-		$scripts = [
-			'first' => ['myFirstJSFile'],
-			'core' => [
-				'core/js/myFancyJSFile1',
-				'core/js/myFancyJSFile4',
-				'core/js/myFancyJSFile5',
-				'core/js/myFancyJSFile1',
-			],
-			'files' => ['files/js/myFancyJSFile2'],
-			'myApp5' => ['myApp5/js/myApp5JSFile'],
-			'myApp' => ['myApp/js/myFancyJSFile3'],
-			'myApp4' => ['myApp4/js/myApp4JSFile'],
-			'myApp3' => ['myApp3/js/myApp3JSFile'],
-			'myApp2' => ['myApp2/js/myApp2JSFile'],
-		];
-		$scriptDeps = [
-			'first' => new AppScriptDependency('first', ['core']),
-			'core' => new AppScriptDependency('core', ['core']),
-			'files' => new AppScriptDependency('files', ['core']),
-			'myApp5' => new AppScriptDependency('myApp5', ['myApp2']),
-			'myApp' => new AppScriptDependency('myApp', ['core']),
-			'myApp4' => new AppScriptDependency('myApp4', ['myApp3']),
-			'myApp3' => new AppScriptDependency('myApp3', ['myApp2']),
-			'myApp2' => new AppScriptDependency('myApp2', ['myApp']),
-		];
-
-		// No circular dependency is detected and logged as an error
-		$this->logger->expects(self::never())->method('error');
-
-		$scriptSort = new AppScriptSort($this->logger);
-		$sortedScripts = $scriptSort->sort($scripts, $scriptDeps);
-
-		$sortedScriptKeys = array_keys($sortedScripts);
-
-		// Core should appear first
-		$this->assertEquals(
-			0,
-			array_search('core', $sortedScriptKeys, true)
-		);
-
-		// Dependencies should appear before their children
-		$this->assertLessThan(
-			array_search('files', $sortedScriptKeys, true),
-			array_search('core', $sortedScriptKeys, true)
-		);
-		$this->assertLessThan(
-			array_search('myApp2', $sortedScriptKeys, true),
-			array_search('myApp', $sortedScriptKeys, true)
-		);
-		$this->assertLessThan(
-			array_search('myApp3', $sortedScriptKeys, true),
-			array_search('myApp2', $sortedScriptKeys, true)
-		);
-		$this->assertLessThan(
-			array_search('myApp4', $sortedScriptKeys, true),
-			array_search('myApp3', $sortedScriptKeys, true)
-		);
-		$this->assertLessThan(
-			array_search('myApp5', $sortedScriptKeys, true),
-			array_search('myApp2', $sortedScriptKeys, true)
-		);
-
-		// All apps still there
-		foreach ($scripts as $app => $_) {
-			$this->assertContains($app, $sortedScriptKeys);
-		}
-	}
-
-	public function testSortCircularDependency(): void {
-		$scripts = [
-			'circular' => ['circular/js/file1'],
-			'dependency' => ['dependency/js/file2'],
-		];
-		$scriptDeps = [
-			'circular' => new AppScriptDependency('circular', ['dependency']),
-			'dependency' => new AppScriptDependency('dependency', ['circular']),
-		];
-
-		// A circular dependency is detected and logged as an error
-		$this->logger->expects(self::once())->method('error');
-
-		$scriptSort = new AppScriptSort($this->logger);
-		$sortedScripts = $scriptSort->sort($scripts, $scriptDeps);
-
-		$sortedScriptKeys = array_keys($sortedScripts);
-
-		// All apps still there
-		foreach ($scripts as $app => $_) {
-			$this->assertContains($app, $sortedScriptKeys);
-		}
-	}
+    private $logger;
+
+    protected function setUp(): void {
+        $this->logger = $this->getMockBuilder(LoggerInterface::class)
+            ->disableOriginalConstructor()
+            ->getMock();
+
+        parent::setUp();
+    }
+
+    public function testSort(): void {
+        $scripts = [
+            'first' => ['myFirstJSFile'],
+            'core' => [
+                'core/js/myFancyJSFile1',
+                'core/js/myFancyJSFile4',
+                'core/js/myFancyJSFile5',
+                'core/js/myFancyJSFile1',
+            ],
+            'files' => ['files/js/myFancyJSFile2'],
+            'myApp5' => ['myApp5/js/myApp5JSFile'],
+            'myApp' => ['myApp/js/myFancyJSFile3'],
+            'myApp4' => ['myApp4/js/myApp4JSFile'],
+            'myApp3' => ['myApp3/js/myApp3JSFile'],
+            'myApp2' => ['myApp2/js/myApp2JSFile'],
+        ];
+        $scriptDeps = [
+            'first' => new AppScriptDependency('first', ['core']),
+            'core' => new AppScriptDependency('core', ['core']),
+            'files' => new AppScriptDependency('files', ['core']),
+            'myApp5' => new AppScriptDependency('myApp5', ['myApp2']),
+            'myApp' => new AppScriptDependency('myApp', ['core']),
+            'myApp4' => new AppScriptDependency('myApp4', ['myApp3']),
+            'myApp3' => new AppScriptDependency('myApp3', ['myApp2']),
+            'myApp2' => new AppScriptDependency('myApp2', ['myApp']),
+        ];
+
+        // No circular dependency is detected and logged as an error
+        $this->logger->expects(self::never())->method('error');
+
+        $scriptSort = new AppScriptSort($this->logger);
+        $sortedScripts = $scriptSort->sort($scripts, $scriptDeps);
+
+        $sortedScriptKeys = array_keys($sortedScripts);
+
+        // Core should appear first
+        $this->assertEquals(
+            0,
+            array_search('core', $sortedScriptKeys, true)
+        );
+
+        // Dependencies should appear before their children
+        $this->assertLessThan(
+            array_search('files', $sortedScriptKeys, true),
+            array_search('core', $sortedScriptKeys, true)
+        );
+        $this->assertLessThan(
+            array_search('myApp2', $sortedScriptKeys, true),
+            array_search('myApp', $sortedScriptKeys, true)
+        );
+        $this->assertLessThan(
+            array_search('myApp3', $sortedScriptKeys, true),
+            array_search('myApp2', $sortedScriptKeys, true)
+        );
+        $this->assertLessThan(
+            array_search('myApp4', $sortedScriptKeys, true),
+            array_search('myApp3', $sortedScriptKeys, true)
+        );
+        $this->assertLessThan(
+            array_search('myApp5', $sortedScriptKeys, true),
+            array_search('myApp2', $sortedScriptKeys, true)
+        );
+
+        // All apps still there
+        foreach ($scripts as $app => $_) {
+            $this->assertContains($app, $sortedScriptKeys);
+        }
+    }
+
+    public function testSortCircularDependency(): void {
+        $scripts = [
+            'circular' => ['circular/js/file1'],
+            'dependency' => ['dependency/js/file2'],
+        ];
+        $scriptDeps = [
+            'circular' => new AppScriptDependency('circular', ['dependency']),
+            'dependency' => new AppScriptDependency('dependency', ['circular']),
+        ];
+
+        // A circular dependency is detected and logged as an error
+        $this->logger->expects(self::once())->method('error');
+
+        $scriptSort = new AppScriptSort($this->logger);
+        $sortedScripts = $scriptSort->sort($scripts, $scriptDeps);
+
+        $sortedScriptKeys = array_keys($sortedScripts);
+
+        // All apps still there
+        foreach ($scripts as $app => $_) {
+            $this->assertContains($app, $sortedScriptKeys);
+        }
+    }
 }

tests/lib/Diagnostics/EventLoggerTest.php

Indentation +40 added lines, -40 removed lines

@@ -14,44 +14,44 @@
 use Test\TestCase;
 
 class EventLoggerTest extends TestCase {
-	/** @var \OC\Diagnostics\EventLogger */
-	private $logger;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->logger = new EventLogger(
-			$this->createMock(SystemConfig::class),
-			$this->createMock(LoggerInterface::class),
-			$this->createMock(Log::class)
-		);
-	}
-
-	public function testQueryLogger(): void {
-		// Module is not activated and this should not be logged
-		$this->logger->start('test1', 'testevent1');
-		$this->logger->end('test1');
-		$this->logger->log('test2', 'testevent2', microtime(true), microtime(true));
-		$events = $this->logger->getEvents();
-		$this->assertSame(0, sizeof($events));
-
-		// Activate module and log some query
-		$this->logger->activate();
-
-		// start one event
-		$this->logger->start('test3', 'testevent3');
-
-		// force log of another event
-		$this->logger->log('test4', 'testevent4', microtime(true), microtime(true));
-
-		// log started event
-		$this->logger->end('test3');
-
-		$events = $this->logger->getEvents();
-		$this->assertSame('test4', $events['test4']->getId());
-		$this->assertSame('testevent4', $events['test4']->getDescription());
-		$this->assertSame('test3', $events['test3']->getId());
-		$this->assertSame('testevent3', $events['test3']->getDescription());
-		$this->assertSame(2, sizeof($events));
-	}
+    /** @var \OC\Diagnostics\EventLogger */
+    private $logger;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->logger = new EventLogger(
+            $this->createMock(SystemConfig::class),
+            $this->createMock(LoggerInterface::class),
+            $this->createMock(Log::class)
+        );
+    }
+
+    public function testQueryLogger(): void {
+        // Module is not activated and this should not be logged
+        $this->logger->start('test1', 'testevent1');
+        $this->logger->end('test1');
+        $this->logger->log('test2', 'testevent2', microtime(true), microtime(true));
+        $events = $this->logger->getEvents();
+        $this->assertSame(0, sizeof($events));
+
+        // Activate module and log some query
+        $this->logger->activate();
+
+        // start one event
+        $this->logger->start('test3', 'testevent3');
+
+        // force log of another event
+        $this->logger->log('test4', 'testevent4', microtime(true), microtime(true));
+
+        // log started event
+        $this->logger->end('test3');
+
+        $events = $this->logger->getEvents();
+        $this->assertSame('test4', $events['test4']->getId());
+        $this->assertSame('testevent4', $events['test4']->getDescription());
+        $this->assertSame('test3', $events['test3']->getId());
+        $this->assertSame('testevent3', $events['test3']->getDescription());
+        $this->assertSame(2, sizeof($events));
+    }
 }