test overhaul

Author: codemasher

tests/AuthenticatorOptionsTest.php

@@ -14,6 +14,7 @@
 use chillerlan\Authenticator\AuthenticatorOptions;
 use chillerlan\Authenticator\Authenticators\AuthenticatorInterface;
 use InvalidArgumentException;
+use PHPUnit\Framework\Attributes\Test;
 use PHPUnit\Framework\TestCase;
 
 class AuthenticatorOptionsTest extends TestCase{
@@ -24,74 +25,100 @@ protected function setUp():void{
 		$this->options = new AuthenticatorOptions;
 	}
 
-	public function testSetDigits():void{
+	#[Test]
+	public function setDigits():void{
 		foreach([6, 8] as $digits){
 			$this->options->digits = $digits;
 			$this::assertSame($digits, $this->options->digits);
 		}
 	}
 
-	public function testSetDigitsException():void{
+	#[Test]
+	public function setDigitsException():void{
 		$this->expectException(InvalidArgumentException::class);
 		$this->expectExceptionMessage('Invalid code length');
 
 		$this->options->digits = 7;
 	}
 
-	public function testSetPeriod():void{
+	#[Test]
+	public function setPeriod():void{
 		for($period = 15; $period <= 60; $period++){
 			$this->options->period = $period;
 			$this::assertSame($period, $this->options->period);
 		}
 	}
 
-	public function testSetPeriodException():void{
+	#[Test]
+	public function setPeriodException():void{
 		$this->expectException(InvalidArgumentException::class);
 		$this->expectExceptionMessage('Invalid period');
 
 		$this->options->period = 666;
 	}
 
-	public function testSetAlgorithm():void{
+	#[Test]
+	public function setAlgorithm():void{
 		foreach(AuthenticatorInterface::HASH_ALGOS as $algo){
 			$this->options->algorithm = $algo;
 			$this::assertSame($algo, $this->options->algorithm);
 		}
 	}
 
-	public function testSetAlgorithmException():void{
+	#[Test]
+	public function setAlgorithmException():void{
 		$this->expectException(InvalidArgumentException::class);
 		$this->expectExceptionMessage('Invalid algorithm');
 
 		$this->options->algorithm = 'florps';
 	}
 
-	public function testSetMode():void{
+	#[Test]
+	public function setMode():void{
 		foreach(AuthenticatorInterface::MODES as $mode => $class){
 			$this->options->mode = $mode;
 			$this::assertSame($mode, $this->options->mode);
 		}
 	}
 
-	public function testSetModeException():void{
+	#[Test]
+	public function setModeException():void{
 		$this->expectException(InvalidArgumentException::class);
 		$this->expectExceptionMessage('Invalid mode');
 
 		$this->options->mode = 'florps';
 	}
 
-	public function testSetAdjacent():void{
+	#[Test]
+	public function setAdjacent():void{
 		for($adjacent = 0; $adjacent <= 10; $adjacent++){
 			$this->options->adjacent = $adjacent;
 			$this::assertSame($adjacent, $this->options->adjacent);
 		}
 	}
 
-	public function testSetAdjacentException():void{
+	#[Test]
+	public function setAdjacentException():void{
 		$this->expectException(InvalidArgumentException::class);
 		$this->expectExceptionMessage('Invalid number of adjacent codes');
 
 		$this->options->adjacent = -1;
 	}
 
+	#[Test]
+	public function setSecretLength():void{
+		for($secretLength = 16; $secretLength <= 1024; $secretLength += 16){
+			$this->options->secret_length = $secretLength;
+			$this::assertSame($secretLength, $this->options->secret_length);
+		}
+	}
+
+	#[Test]
+	public function setSecretLengthException():void{
+		$this->expectException(InvalidArgumentException::class);
+		$this->expectExceptionMessage('Invalid secret length: 69420');
+
+		$this->options->secret_length = 69420;
+	}
+
 }

tests/AuthenticatorTest.php

@@ -12,10 +12,9 @@
 namespace chillerlan\AuthenticatorTest;
 
 use chillerlan\Authenticator\{Authenticator, AuthenticatorOptions};
-use chillerlan\Authenticator\Authenticators\AuthenticatorInterface;
-use InvalidArgumentException;
+use PHPUnit\Framework\Attributes\Test;
 use PHPUnit\Framework\TestCase;
-use function sprintf;
+use InvalidArgumentException;
 
 class AuthenticatorTest extends TestCase{
 
@@ -31,60 +30,15 @@ protected function setUp():void{
 		$this->authenticator = new Authenticator($this->options);
 	}
 
-	public function testSetSecretViaConstruct():void{
+	#[Test]
+	public function setSecretViaConstruct():void{
 		$this->authenticator = new Authenticator(secret: self::secret);
 
 		$this::assertSame(self::secret, $this->authenticator->getSecret());
 	}
 
-	public function testGetUri():void{
-		$this->authenticator->setSecret(self::secret);
-
-		$label  = rawurlencode(self::label);
-		$issuer = rawurlencode(self::issuer);
-
-		$this::assertSame(
-			sprintf('otpauth://totp/%s?secret=%s&issuer=%s&digits=6&algorithm=SHA1&period=30', $label, self::secret, $issuer),
-			$this->authenticator->getUri(self::label, self::issuer),
-		);
-
-		$this->options->digits = 8;
-		$this::assertSame(
-			sprintf('otpauth://totp/%s?secret=%s&issuer=%s&digits=8&algorithm=SHA1&period=30', $label, self::secret, $issuer),
-			$this->authenticator->getUri(self::label, self::issuer),
-		);
-
-		$this->options->period = 45;
-		$this::assertSame(
-			sprintf('otpauth://totp/%s?secret=%s&issuer=%s&digits=8&algorithm=SHA1&period=45', $label, self::secret, $issuer),
-			$this->authenticator->getUri(self::label, self::issuer),
-		);
-
-		$this->options->mode = AuthenticatorInterface::HOTP;
-		// changing the mode resets the AuthenticatorInterface instance
-		$this->authenticator
-			->setOptions($this->options)
-			->setSecret(self::secret);
-
-		$this::assertSame(
-			sprintf('otpauth://hotp/%s?secret=%s&issuer=%s&counter=42&digits=8&algorithm=SHA1', $label, self::secret, $issuer),
-			$this->authenticator->getUri(self::label, self::issuer, 42),
-		);
-
-		$this->options->algorithm = AuthenticatorInterface::ALGO_SHA512;
-		$this::assertSame(
-			sprintf('otpauth://hotp/%s?secret=%s&issuer=%s&counter=0&digits=8&algorithm=SHA512', $label, self::secret, $issuer),
-			$this->authenticator->getUri(self::label, self::issuer, 0),
-		);
-
-		// test omit settings
-		$this::assertSame(
-			sprintf('otpauth://%s/%s?secret=%s&issuer=%s&counter=42', 'hotp', $label, self::secret, $issuer),
-			$this->authenticator->getUri(self::label, self::issuer, 42, true),
-		);
-	}
-
-	public function testGetUriEmptyLabelException():void{
+	#[Test]
+	public function getUriEmptyLabelException():void{
 		$this->expectException(InvalidArgumentException::class);
 		$this->expectExceptionMessage('$label and $issuer cannot be empty');
 

tests/Authenticators/AuthenticatorInterfaceTestAbstract.php

@@ -14,10 +14,10 @@
 use chillerlan\Authenticator\AuthenticatorOptions;
 use chillerlan\Authenticator\Authenticators\AuthenticatorInterface;
 use chillerlan\Authenticator\Common\Base32;
-use InvalidArgumentException;
 use PHPUnit\Framework\TestCase;
-use RuntimeException;
-use function strlen;
+use PHPUnit\Framework\Attributes\{DataProvider, Test};
+use InvalidArgumentException, RuntimeException;
+use function rawurlencode, sprintf, strlen;
 
 abstract class AuthenticatorInterfaceTestAbstract extends TestCase{
 
@@ -27,14 +27,18 @@ abstract class AuthenticatorInterfaceTestAbstract extends TestCase{
 	protected const rawsecret = '12345678901234567890';
 	protected const secret    = 'GEZDGNBVGY3TQOJQGEZDGNBVGY3TQOJQ';
 
+	protected const label     = 'some test-label';
+	protected const issuer    = 'chillerlan.net';
+
 	abstract protected function getInstance(AuthenticatorOptions $options):AuthenticatorInterface;
 
 	protected function setUp():void{
 		$this->options                = new AuthenticatorOptions;
 		$this->authenticatorInterface = $this->getInstance($this->options);
 	}
 
-	public function testSetGetSecret():void{
+	#[Test]
+	public function setGetSecret():void{
 		$this->authenticatorInterface->setSecret($this::secret);
 
 		$secret = $this->authenticatorInterface->getSecret();
@@ -43,34 +47,39 @@ public function testSetGetSecret():void{
 		$this::assertSame($this::rawsecret, Base32::decode($secret));
 	}
 
-	public function testSetEmptySecretException():void{
+	#[Test]
+	public function setEmptySecretException():void{
 		$this->expectException(InvalidArgumentException::class);
 		$this->expectExceptionMessage('The given secret string is empty');
 
 		$this->authenticatorInterface->setSecret('');
 	}
 
-	public function testSetInvalidSecretException():void{
+	#[Test]
+	public function setInvalidSecretException():void{
 		$this->expectException(InvalidArgumentException::class);
 
 		$this->authenticatorInterface->setSecret('This_is_an_invalid_secret_phrase!');
 	}
 
-	public function testGetSecretException():void{
+	#[Test]
+	public function getSecretException():void{
 		$this->expectException(RuntimeException::class);
 		$this->expectExceptionMessage('No secret set');
 
 		$this->authenticatorInterface->getSecret();
 	}
 
-	public function testCreateSecretDefaultLength():void{
+	#[Test]
+	public function createSecretDefaultLength():void{
 		$this::assertSame(
 			$this->options->secret_length,
 			strlen(Base32::decode($this->authenticatorInterface->createSecret())),
 		);
 	}
 
-	public function testCreateSecretWithLength():void{
+	#[Test]
+	public function createSecretWithLength():void{
 
 		for($secretLength = 16; $secretLength <= 512; $secretLength += 8){
 			$secret = Base32::decode($this->authenticatorInterface->createSecret($secretLength));
@@ -80,28 +89,32 @@ public function testCreateSecretWithLength():void{
 
 	}
 
-	public function testCreateSecretCheckCharacterSet():void{
+	#[Test]
+	public function createSecretCheckCharacterSet():void{
 		$secret = $this->authenticatorInterface->createSecret(32);
 
 		$this::assertMatchesRegularExpression('/^['.Base32::CHARSET.']+$/', $secret);
 	}
 
-	public function testCreateSecretException():void{
+	#[Test]
+	public function createSecretException():void{
 		$this->expectException(InvalidArgumentException::class);
 		$this->expectExceptionMessage('Invalid secret length');
 
 		$this->authenticatorInterface->createSecret(10);
 	}
 
-	public function testGetHMACWithoutSecretException():void{
+	#[Test]
+	public function getHMACWithoutSecretException():void{
 		$this->expectException(RuntimeException::class);
 		$this->expectExceptionMessage('No secret given');
 
 		$this->authenticatorInterface->getHMAC(69);
 	}
 
 	// https://github.com/PHPGangsta/GoogleAuthenticator/pull/25
-	public function testVerifyCodeWithLeadingZero():void{
+	#[Test]
+	public function verifyCodeWithLeadingZero():void{
 		$this->authenticatorInterface->setSecret($this::secret);
 
 		$code = $this->authenticatorInterface->code();
@@ -111,7 +124,8 @@ public function testVerifyCodeWithLeadingZero():void{
 	}
 
 	// coverage
-	public function testGetServertime():void{
+	#[Test]
+	public function getServertime():void{
 		$this->options->useLocalTime = false;
 
 		$servertime = $this->authenticatorInterface->getServerTime();
@@ -123,4 +137,32 @@ public function testGetServertime():void{
 		$this::assertMatchesRegularExpression('/^\d+$/', (string)$servertime);
 	}
 
+	abstract public static function uriSettingsProvider():array;
+
+	/**
+	 * @param array<string, mixed> $options
+	 */
+	#[Test]
+	#[DataProvider('uriSettingsProvider')]
+	public function getUri(array $options, string $expected):void{
+
+		$this->authenticatorInterface
+			->setOptions($options)
+			->setSecret(self::secret)
+		;
+
+		$this::assertSame(
+			sprintf(
+				'otpauth://%s/%s?secret=%s&issuer=%s%s',
+				$this->authenticatorInterface::MODE,
+				rawurlencode(self::label),
+				self::secret,
+				rawurlencode(self::issuer),
+				$expected,
+			),
+			$this->authenticatorInterface->getUri(self::label, self::issuer, 42),
+		);
+
+	}
+
 }

tests/Authenticators/HOTPTest.php

@@ -13,10 +13,9 @@
 
 use chillerlan\Authenticator\AuthenticatorOptions;
 use chillerlan\Authenticator\Authenticators\{AuthenticatorInterface, HOTP};
+use PHPUnit\Framework\Attributes\{DataProvider, Test};
 use Generator;
-use PHPUnit\Framework\Attributes\DataProvider;
-use function bin2hex;
-use function sprintf;
+use function bin2hex,  sprintf;
 
 class HOTPTest extends AuthenticatorInterfaceTestAbstract{
 
@@ -49,8 +48,9 @@ public static function hotpVectors():Generator{
 	/**
 	 * @link https://github.com/winauth/winauth/issues/449#issuecomment-353670105
 	 */
+	#[Test]
 	#[DataProvider('hotpVectors')]
-	public function testHOTP(int $counter, string $hmac, int $code, string $hotp):void{
+	public function HOTP(int $counter, string $hmac, int $code, string $hotp):void{
 		$this->authenticatorInterface->setSecret($this::secret);
 
 		$hmac_intermediate = $this->authenticatorInterface->getHMAC($counter);
@@ -62,4 +62,13 @@ public function testHOTP(int $counter, string $hmac, int $code, string $hotp):vo
 		$this::assertTrue($this->authenticatorInterface->verify($hotp, $counter));
 	}
 
+	public static function uriSettingsProvider():array{
+		return [
+			'default' => [[], '&counter=42&digits=6&algorithm=SHA1'],
+			'digits'  => [['digits' => 8], '&counter=42&digits=8&algorithm=SHA1'],
+			'algo'    => [['algorithm' => AuthenticatorInterface::ALGO_SHA512], '&counter=42&digits=6&algorithm=SHA512'],
+			'omit'    => [['omitUriSettings' => true], '&counter=42'],
+		];
+	}
+
 }