nextcloud / server

apps/settings/tests/Integration/DuplicateAssignmentIntegrationTest.php

Indentation +134 added lines, -134 removed lines

@@ -20,138 +20,138 @@
 #[\PHPUnit\Framework\Attributes\Group('DB')]
 class DuplicateAssignmentIntegrationTest extends TestCase {
 
-	private AuthorizedGroupService $service;
-	private AuthorizedGroupMapper $mapper;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		// Use real mapper for integration testing
-		$this->mapper = \OCP\Server::get(AuthorizedGroupMapper::class);
-		$this->service = new AuthorizedGroupService($this->mapper);
-	}
-
-	protected function tearDown(): void {
-		// Clean up any test data
-		try {
-			$allGroups = $this->mapper->findAll();
-			foreach ($allGroups as $group) {
-				if (str_starts_with($group->getGroupId(), 'test_')
-					|| str_starts_with($group->getClass(), 'TestClass')) {
-					$this->mapper->delete($group);
-				}
-			}
-		} catch (\Exception $e) {
-			// Ignore cleanup errors
-		}
-		parent::tearDown();
-	}
-
-	public function testDuplicateAssignmentPrevention(): void {
-		$groupId = 'test_duplicate_group';
-		$class = 'TestClass\\DuplicateTest';
-
-		// First assignment should succeed
-		$result1 = $this->service->create($groupId, $class);
-		$this->assertInstanceOf(AuthorizedGroup::class, $result1);
-		$this->assertEquals($groupId, $result1->getGroupId());
-		$this->assertEquals($class, $result1->getClass());
-		$this->assertNotNull($result1->getId());
-
-		// Second assignment of same group to same class should throw ConflictException
-		$this->expectException(ConflictException::class);
-		$this->expectExceptionMessage('Group is already assigned to this class');
-
-		$this->service->create($groupId, $class);
-	}
-
-	public function testDifferentGroupsSameClassAllowed(): void {
-		$groupId1 = 'test_group_1';
-		$groupId2 = 'test_group_2';
-		$class = 'TestClass\\MultiGroup';
-
-		// Both assignments should succeed
-		$result1 = $this->service->create($groupId1, $class);
-		$result2 = $this->service->create($groupId2, $class);
-
-		$this->assertEquals($groupId1, $result1->getGroupId());
-		$this->assertEquals($groupId2, $result2->getGroupId());
-		$this->assertEquals($class, $result1->getClass());
-		$this->assertEquals($class, $result2->getClass());
-		$this->assertNotEquals($result1->getId(), $result2->getId());
-	}
-
-	public function testSameGroupDifferentClassesAllowed(): void {
-		$groupId = 'test_multi_class_group';
-		$class1 = 'TestClass\\First';
-		$class2 = 'TestClass\\Second';
-
-		// Both assignments should succeed
-		$result1 = $this->service->create($groupId, $class1);
-		$result2 = $this->service->create($groupId, $class2);
-
-		$this->assertEquals($groupId, $result1->getGroupId());
-		$this->assertEquals($groupId, $result2->getGroupId());
-		$this->assertEquals($class1, $result1->getClass());
-		$this->assertEquals($class2, $result2->getClass());
-		$this->assertNotEquals($result1->getId(), $result2->getId());
-	}
-
-	public function testCreateAfterDelete(): void {
-		$groupId = 'test_recreate_group';
-		$class = 'TestClass\\Recreate';
-
-		// Create initial assignment
-		$result1 = $this->service->create($groupId, $class);
-		$initialId = $result1->getId();
-
-		// Delete the assignment
-		$this->service->delete($initialId);
-
-		// Verify it's deleted by trying to find it
-		$this->expectException(\OCP\AppFramework\Db\DoesNotExistException::class);
-		try {
-			$this->service->find($initialId);
-		} catch (\OCA\Settings\Service\NotFoundException $e) {
-			// Expected - now create the same assignment again, which should succeed
-			$result2 = $this->service->create($groupId, $class);
-
-			$this->assertEquals($groupId, $result2->getGroupId());
-			$this->assertEquals($class, $result2->getClass());
-			$this->assertNotEquals($initialId, $result2->getId());
-			return;
-		}
-
-		$this->fail('Expected NotFoundException when finding deleted group');
-	}
-
-	/**
-	 * Test the mapper's findByGroupIdAndClass method behavior with duplicates
-	 */
-	public function testMapperFindByGroupIdAndClassBehavior(): void {
-		$groupId = 'test_mapper_group';
-		$class = 'TestClass\\MapperTest';
-
-		// Initially should throw DoesNotExistException
-		$this->expectException(DoesNotExistException::class);
-		$this->mapper->findByGroupIdAndClass($groupId, $class);
-	}
-
-	/**
-	 * Test that mapper returns existing record after creation
-	 */
-	public function testMapperFindsExistingRecord(): void {
-		$groupId = 'test_existing_group';
-		$class = 'TestClass\\Existing';
-
-		// Create the record first
-		$created = $this->service->create($groupId, $class);
-
-		// Now mapper should find it
-		$found = $this->mapper->findByGroupIdAndClass($groupId, $class);
-
-		$this->assertEquals($created->getId(), $found->getId());
-		$this->assertEquals($groupId, $found->getGroupId());
-		$this->assertEquals($class, $found->getClass());
-	}
+    private AuthorizedGroupService $service;
+    private AuthorizedGroupMapper $mapper;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        // Use real mapper for integration testing
+        $this->mapper = \OCP\Server::get(AuthorizedGroupMapper::class);
+        $this->service = new AuthorizedGroupService($this->mapper);
+    }
+
+    protected function tearDown(): void {
+        // Clean up any test data
+        try {
+            $allGroups = $this->mapper->findAll();
+            foreach ($allGroups as $group) {
+                if (str_starts_with($group->getGroupId(), 'test_')
+                    || str_starts_with($group->getClass(), 'TestClass')) {
+                    $this->mapper->delete($group);
+                }
+            }
+        } catch (\Exception $e) {
+            // Ignore cleanup errors
+        }
+        parent::tearDown();
+    }
+
+    public function testDuplicateAssignmentPrevention(): void {
+        $groupId = 'test_duplicate_group';
+        $class = 'TestClass\\DuplicateTest';
+
+        // First assignment should succeed
+        $result1 = $this->service->create($groupId, $class);
+        $this->assertInstanceOf(AuthorizedGroup::class, $result1);
+        $this->assertEquals($groupId, $result1->getGroupId());
+        $this->assertEquals($class, $result1->getClass());
+        $this->assertNotNull($result1->getId());
+
+        // Second assignment of same group to same class should throw ConflictException
+        $this->expectException(ConflictException::class);
+        $this->expectExceptionMessage('Group is already assigned to this class');
+
+        $this->service->create($groupId, $class);
+    }
+
+    public function testDifferentGroupsSameClassAllowed(): void {
+        $groupId1 = 'test_group_1';
+        $groupId2 = 'test_group_2';
+        $class = 'TestClass\\MultiGroup';
+
+        // Both assignments should succeed
+        $result1 = $this->service->create($groupId1, $class);
+        $result2 = $this->service->create($groupId2, $class);
+
+        $this->assertEquals($groupId1, $result1->getGroupId());
+        $this->assertEquals($groupId2, $result2->getGroupId());
+        $this->assertEquals($class, $result1->getClass());
+        $this->assertEquals($class, $result2->getClass());
+        $this->assertNotEquals($result1->getId(), $result2->getId());
+    }
+
+    public function testSameGroupDifferentClassesAllowed(): void {
+        $groupId = 'test_multi_class_group';
+        $class1 = 'TestClass\\First';
+        $class2 = 'TestClass\\Second';
+
+        // Both assignments should succeed
+        $result1 = $this->service->create($groupId, $class1);
+        $result2 = $this->service->create($groupId, $class2);
+
+        $this->assertEquals($groupId, $result1->getGroupId());
+        $this->assertEquals($groupId, $result2->getGroupId());
+        $this->assertEquals($class1, $result1->getClass());
+        $this->assertEquals($class2, $result2->getClass());
+        $this->assertNotEquals($result1->getId(), $result2->getId());
+    }
+
+    public function testCreateAfterDelete(): void {
+        $groupId = 'test_recreate_group';
+        $class = 'TestClass\\Recreate';
+
+        // Create initial assignment
+        $result1 = $this->service->create($groupId, $class);
+        $initialId = $result1->getId();
+
+        // Delete the assignment
+        $this->service->delete($initialId);
+
+        // Verify it's deleted by trying to find it
+        $this->expectException(\OCP\AppFramework\Db\DoesNotExistException::class);
+        try {
+            $this->service->find($initialId);
+        } catch (\OCA\Settings\Service\NotFoundException $e) {
+            // Expected - now create the same assignment again, which should succeed
+            $result2 = $this->service->create($groupId, $class);
+
+            $this->assertEquals($groupId, $result2->getGroupId());
+            $this->assertEquals($class, $result2->getClass());
+            $this->assertNotEquals($initialId, $result2->getId());
+            return;
+        }
+
+        $this->fail('Expected NotFoundException when finding deleted group');
+    }
+
+    /**
+     * Test the mapper's findByGroupIdAndClass method behavior with duplicates
+     */
+    public function testMapperFindByGroupIdAndClassBehavior(): void {
+        $groupId = 'test_mapper_group';
+        $class = 'TestClass\\MapperTest';
+
+        // Initially should throw DoesNotExistException
+        $this->expectException(DoesNotExistException::class);
+        $this->mapper->findByGroupIdAndClass($groupId, $class);
+    }
+
+    /**
+     * Test that mapper returns existing record after creation
+     */
+    public function testMapperFindsExistingRecord(): void {
+        $groupId = 'test_existing_group';
+        $class = 'TestClass\\Existing';
+
+        // Create the record first
+        $created = $this->service->create($groupId, $class);
+
+        // Now mapper should find it
+        $found = $this->mapper->findByGroupIdAndClass($groupId, $class);
+
+        $this->assertEquals($created->getId(), $found->getId());
+        $this->assertEquals($groupId, $found->getGroupId());
+        $this->assertEquals($class, $found->getClass());
+    }
 }

apps/settings/tests/Service/AuthorizedGroupServiceTest.php

Indentation +136 added lines, -136 removed lines

@@ -19,140 +19,140 @@
 
 class AuthorizedGroupServiceTest extends TestCase {
 
-	private AuthorizedGroupMapper&MockObject $mapper;
-	private AuthorizedGroupService $service;
-
-	protected function setUp(): void {
-		parent::setUp();
-		$this->mapper = $this->createMock(AuthorizedGroupMapper::class);
-		$this->service = new AuthorizedGroupService($this->mapper);
-	}
-
-	public function testCreateSuccessWhenNoDuplicateExists(): void {
-		$groupId = 'testgroup';
-		$class = 'TestClass';
-
-		// Mock that no existing assignment is found (throws DoesNotExistException)
-		$this->mapper->expects($this->once())
-			->method('findByGroupIdAndClass')
-			->with($groupId, $class)
-			->willThrowException(new DoesNotExistException('Not found'));
-
-		// Mock the successful creation
-		$expectedGroup = new AuthorizedGroup();
-		$expectedGroup->setGroupId($groupId);
-		$expectedGroup->setClass($class);
-		$expectedGroup->setId(123);
-
-		$this->mapper->expects($this->once())
-			->method('insert')
-			->willReturn($expectedGroup);
-
-		$result = $this->service->create($groupId, $class);
-
-		$this->assertInstanceOf(AuthorizedGroup::class, $result);
-		$this->assertEquals($groupId, $result->getGroupId());
-		$this->assertEquals($class, $result->getClass());
-	}
-
-	public function testCreateThrowsConflictExceptionWhenDuplicateExists(): void {
-		$groupId = 'testgroup';
-		$class = 'TestClass';
-
-		// Mock that an existing assignment is found
-		$existingGroup = new AuthorizedGroup();
-		$existingGroup->setGroupId($groupId);
-		$existingGroup->setClass($class);
-		$existingGroup->setId(42);
-
-		$this->mapper->expects($this->once())
-			->method('findByGroupIdAndClass')
-			->with($groupId, $class)
-			->willReturn($existingGroup);
-
-		// Mapper insert should never be called when duplicate exists
-		$this->mapper->expects($this->never())
-			->method('insert');
-
-		$this->expectException(ConflictException::class);
-		$this->expectExceptionMessage('Group is already assigned to this class');
-
-		$this->service->create($groupId, $class);
-	}
-
-	public function testCreateAllowsDifferentGroupsSameClass(): void {
-		$groupId1 = 'testgroup1';
-		$groupId2 = 'testgroup2';
-		$class = 'TestClass';
-
-		// Mock that no duplicate exists for group1
-		$this->mapper->expects($this->exactly(2))
-			->method('findByGroupIdAndClass')
-			->willReturnCallback(function ($groupId, $classArg) use ($groupId1, $groupId2, $class) {
-				$this->assertContains($groupId, [$groupId1, $groupId2]);
-				$this->assertEquals($class, $classArg);
-				throw new DoesNotExistException('Not found');
-			});
-
-		$expectedGroup1 = new AuthorizedGroup();
-		$expectedGroup1->setGroupId($groupId1);
-		$expectedGroup1->setClass($class);
-		$expectedGroup1->setId(123);
-
-		$expectedGroup2 = new AuthorizedGroup();
-		$expectedGroup2->setGroupId($groupId2);
-		$expectedGroup2->setClass($class);
-		$expectedGroup2->setId(124);
-
-		$this->mapper->expects($this->exactly(2))
-			->method('insert')
-			->willReturnOnConsecutiveCalls($expectedGroup1, $expectedGroup2);
-
-		// Both creations should succeed
-		$result1 = $this->service->create($groupId1, $class);
-		$this->assertEquals($groupId1, $result1->getGroupId());
-		$this->assertEquals($class, $result1->getClass());
-
-		$result2 = $this->service->create($groupId2, $class);
-		$this->assertEquals($groupId2, $result2->getGroupId());
-		$this->assertEquals($class, $result2->getClass());
-	}
-
-	public function testCreateAllowsSameGroupDifferentClasses(): void {
-		$groupId = 'testgroup';
-		$class1 = 'TestClass1';
-		$class2 = 'TestClass2';
-
-		// Mock that no duplicate exists for either class
-		$this->mapper->expects($this->exactly(2))
-			->method('findByGroupIdAndClass')
-			->willReturnCallback(function ($groupIdArg, $class) use ($groupId, $class1, $class2) {
-				$this->assertEquals($groupId, $groupIdArg);
-				$this->assertContains($class, [$class1, $class2]);
-				throw new DoesNotExistException('Not found');
-			});
-
-		$expectedGroup1 = new AuthorizedGroup();
-		$expectedGroup1->setGroupId($groupId);
-		$expectedGroup1->setClass($class1);
-		$expectedGroup1->setId(123);
-
-		$expectedGroup2 = new AuthorizedGroup();
-		$expectedGroup2->setGroupId($groupId);
-		$expectedGroup2->setClass($class2);
-		$expectedGroup2->setId(124);
-
-		$this->mapper->expects($this->exactly(2))
-			->method('insert')
-			->willReturnOnConsecutiveCalls($expectedGroup1, $expectedGroup2);
-
-		// Both creations should succeed
-		$result1 = $this->service->create($groupId, $class1);
-		$result2 = $this->service->create($groupId, $class2);
-
-		$this->assertEquals($groupId, $result1->getGroupId());
-		$this->assertEquals($groupId, $result2->getGroupId());
-		$this->assertEquals($class1, $result1->getClass());
-		$this->assertEquals($class2, $result2->getClass());
-	}
+    private AuthorizedGroupMapper&MockObject $mapper;
+    private AuthorizedGroupService $service;
+
+    protected function setUp(): void {
+        parent::setUp();
+        $this->mapper = $this->createMock(AuthorizedGroupMapper::class);
+        $this->service = new AuthorizedGroupService($this->mapper);
+    }
+
+    public function testCreateSuccessWhenNoDuplicateExists(): void {
+        $groupId = 'testgroup';
+        $class = 'TestClass';
+
+        // Mock that no existing assignment is found (throws DoesNotExistException)
+        $this->mapper->expects($this->once())
+            ->method('findByGroupIdAndClass')
+            ->with($groupId, $class)
+            ->willThrowException(new DoesNotExistException('Not found'));
+
+        // Mock the successful creation
+        $expectedGroup = new AuthorizedGroup();
+        $expectedGroup->setGroupId($groupId);
+        $expectedGroup->setClass($class);
+        $expectedGroup->setId(123);
+
+        $this->mapper->expects($this->once())
+            ->method('insert')
+            ->willReturn($expectedGroup);
+
+        $result = $this->service->create($groupId, $class);
+
+        $this->assertInstanceOf(AuthorizedGroup::class, $result);
+        $this->assertEquals($groupId, $result->getGroupId());
+        $this->assertEquals($class, $result->getClass());
+    }
+
+    public function testCreateThrowsConflictExceptionWhenDuplicateExists(): void {
+        $groupId = 'testgroup';
+        $class = 'TestClass';
+
+        // Mock that an existing assignment is found
+        $existingGroup = new AuthorizedGroup();
+        $existingGroup->setGroupId($groupId);
+        $existingGroup->setClass($class);
+        $existingGroup->setId(42);
+
+        $this->mapper->expects($this->once())
+            ->method('findByGroupIdAndClass')
+            ->with($groupId, $class)
+            ->willReturn($existingGroup);
+
+        // Mapper insert should never be called when duplicate exists
+        $this->mapper->expects($this->never())
+            ->method('insert');
+
+        $this->expectException(ConflictException::class);
+        $this->expectExceptionMessage('Group is already assigned to this class');
+
+        $this->service->create($groupId, $class);
+    }
+
+    public function testCreateAllowsDifferentGroupsSameClass(): void {
+        $groupId1 = 'testgroup1';
+        $groupId2 = 'testgroup2';
+        $class = 'TestClass';
+
+        // Mock that no duplicate exists for group1
+        $this->mapper->expects($this->exactly(2))
+            ->method('findByGroupIdAndClass')
+            ->willReturnCallback(function ($groupId, $classArg) use ($groupId1, $groupId2, $class) {
+                $this->assertContains($groupId, [$groupId1, $groupId2]);
+                $this->assertEquals($class, $classArg);
+                throw new DoesNotExistException('Not found');
+            });
+
+        $expectedGroup1 = new AuthorizedGroup();
+        $expectedGroup1->setGroupId($groupId1);
+        $expectedGroup1->setClass($class);
+        $expectedGroup1->setId(123);
+
+        $expectedGroup2 = new AuthorizedGroup();
+        $expectedGroup2->setGroupId($groupId2);
+        $expectedGroup2->setClass($class);
+        $expectedGroup2->setId(124);
+
+        $this->mapper->expects($this->exactly(2))
+            ->method('insert')
+            ->willReturnOnConsecutiveCalls($expectedGroup1, $expectedGroup2);
+
+        // Both creations should succeed
+        $result1 = $this->service->create($groupId1, $class);
+        $this->assertEquals($groupId1, $result1->getGroupId());
+        $this->assertEquals($class, $result1->getClass());
+
+        $result2 = $this->service->create($groupId2, $class);
+        $this->assertEquals($groupId2, $result2->getGroupId());
+        $this->assertEquals($class, $result2->getClass());
+    }
+
+    public function testCreateAllowsSameGroupDifferentClasses(): void {
+        $groupId = 'testgroup';
+        $class1 = 'TestClass1';
+        $class2 = 'TestClass2';
+
+        // Mock that no duplicate exists for either class
+        $this->mapper->expects($this->exactly(2))
+            ->method('findByGroupIdAndClass')
+            ->willReturnCallback(function ($groupIdArg, $class) use ($groupId, $class1, $class2) {
+                $this->assertEquals($groupId, $groupIdArg);
+                $this->assertContains($class, [$class1, $class2]);
+                throw new DoesNotExistException('Not found');
+            });
+
+        $expectedGroup1 = new AuthorizedGroup();
+        $expectedGroup1->setGroupId($groupId);
+        $expectedGroup1->setClass($class1);
+        $expectedGroup1->setId(123);
+
+        $expectedGroup2 = new AuthorizedGroup();
+        $expectedGroup2->setGroupId($groupId);
+        $expectedGroup2->setClass($class2);
+        $expectedGroup2->setId(124);
+
+        $this->mapper->expects($this->exactly(2))
+            ->method('insert')
+            ->willReturnOnConsecutiveCalls($expectedGroup1, $expectedGroup2);
+
+        // Both creations should succeed
+        $result1 = $this->service->create($groupId, $class1);
+        $result2 = $this->service->create($groupId, $class2);
+
+        $this->assertEquals($groupId, $result1->getGroupId());
+        $this->assertEquals($groupId, $result2->getGroupId());
+        $this->assertEquals($class1, $result1->getClass());
+        $this->assertEquals($class2, $result2->getClass());
+    }
 }

apps/settings/tests/Command/AdminDelegation/AddTest.php

Indentation +123 added lines, -123 removed lines

@@ -22,127 +22,127 @@
 
 class AddTest extends TestCase {
 
-	private IManager&MockObject $settingManager;
-	private AuthorizedGroupService&MockObject $authorizedGroupService;
-	private IGroupManager&MockObject $groupManager;
-	private Add $command;
-	private InputInterface&MockObject $input;
-	private OutputInterface&MockObject $output;
-
-	protected function setUp(): void {
-		parent::setUp();
-
-		$this->settingManager = $this->createMock(IManager::class);
-		$this->authorizedGroupService = $this->createMock(AuthorizedGroupService::class);
-		$this->groupManager = $this->createMock(IGroupManager::class);
-
-		$this->command = new Add(
-			$this->settingManager,
-			$this->authorizedGroupService,
-			$this->groupManager
-		);
-
-		$this->input = $this->createMock(InputInterface::class);
-		$this->output = $this->createMock(OutputInterface::class);
-	}
-
-	public function testExecuteSuccessfulDelegation(): void {
-		$settingClass = Server::class;
-		$groupId = 'testgroup';
-
-		// Mock valid delegated settings class
-		$this->input->expects($this->exactly(2))
-			->method('getArgument')
-			->willReturnMap([
-				['settingClass', $settingClass],
-				['groupId', $groupId]
-			]);
-
-		// Mock group exists
-		$this->groupManager->expects($this->once())
-			->method('groupExists')
-			->with($groupId)
-			->willReturn(true);
-
-		// Mock successful creation
-		$authorizedGroup = new AuthorizedGroup();
-		$authorizedGroup->setGroupId($groupId);
-		$authorizedGroup->setClass($settingClass);
-
-		$this->authorizedGroupService->expects($this->once())
-			->method('create')
-			->with($groupId, $settingClass)
-			->willReturn($authorizedGroup);
-
-		$result = $this->command->execute($this->input, $this->output);
-
-		$this->assertEquals(0, $result);
-	}
-
-	public function testExecuteHandlesDuplicateAssignment(): void {
-		$settingClass = 'OCA\\Settings\\Settings\\Admin\\Server';
-		$groupId = 'testgroup';
-
-		// Mock valid delegated settings class
-		$this->input->expects($this->exactly(2))
-			->method('getArgument')
-			->willReturnMap([
-				['settingClass', $settingClass],
-				['groupId', $groupId]
-			]);
-
-		// Mock group exists
-		$this->groupManager->expects($this->once())
-			->method('groupExists')
-			->with($groupId)
-			->willReturn(true);
-
-		// Mock ConflictException when trying to create duplicate
-		$this->authorizedGroupService->expects($this->once())
-			->method('create')
-			->with($groupId, $settingClass)
-			->willThrowException(new ConflictException('Group is already assigned to this class'));
-
-		$result = $this->command->execute($this->input, $this->output);
-
-		$this->assertEquals(4, $result, 'Duplicate assignment should return exit code 4');
-	}
-
-	public function testExecuteInvalidSettingClass(): void {
-		// Use a real class that exists but doesn't implement IDelegatedSettings
-		$settingClass = 'stdClass';
-
-		$this->input->expects($this->once())
-			->method('getArgument')
-			->with('settingClass')
-			->willReturn($settingClass);
-
-		$result = $this->command->execute($this->input, $this->output);
-
-		// Should return exit code 2 for invalid setting class
-		$this->assertEquals(2, $result);
-	}
-
-	public function testExecuteNonExistentGroup(): void {
-		$settingClass = Server::class;
-		$groupId = 'nonexistentgroup';
-
-		$this->input->expects($this->exactly(2))
-			->method('getArgument')
-			->willReturnMap([
-				['settingClass', $settingClass],
-				['groupId', $groupId]
-			]);
-
-		// Mock group does not exist
-		$this->groupManager->expects($this->once())
-			->method('groupExists')
-			->with($groupId)
-			->willReturn(false);
-
-		$result = $this->command->execute($this->input, $this->output);
-
-		// Should return exit code 3 for non-existent group
-		$this->assertEquals(3, $result);
-	}
+    private IManager&MockObject $settingManager;
+    private AuthorizedGroupService&MockObject $authorizedGroupService;
+    private IGroupManager&MockObject $groupManager;
+    private Add $command;
+    private InputInterface&MockObject $input;
+    private OutputInterface&MockObject $output;
+
+    protected function setUp(): void {
+        parent::setUp();
+
+        $this->settingManager = $this->createMock(IManager::class);
+        $this->authorizedGroupService = $this->createMock(AuthorizedGroupService::class);
+        $this->groupManager = $this->createMock(IGroupManager::class);
+
+        $this->command = new Add(
+            $this->settingManager,
+            $this->authorizedGroupService,
+            $this->groupManager
+        );
+
+        $this->input = $this->createMock(InputInterface::class);
+        $this->output = $this->createMock(OutputInterface::class);
+    }
+
+    public function testExecuteSuccessfulDelegation(): void {
+        $settingClass = Server::class;
+        $groupId = 'testgroup';
+
+        // Mock valid delegated settings class
+        $this->input->expects($this->exactly(2))
+            ->method('getArgument')
+            ->willReturnMap([
+                ['settingClass', $settingClass],
+                ['groupId', $groupId]
+            ]);
+
+        // Mock group exists
+        $this->groupManager->expects($this->once())
+            ->method('groupExists')
+            ->with($groupId)
+            ->willReturn(true);
+
+        // Mock successful creation
+        $authorizedGroup = new AuthorizedGroup();
+        $authorizedGroup->setGroupId($groupId);
+        $authorizedGroup->setClass($settingClass);
+
+        $this->authorizedGroupService->expects($this->once())
+            ->method('create')
+            ->with($groupId, $settingClass)
+            ->willReturn($authorizedGroup);
+
+        $result = $this->command->execute($this->input, $this->output);
+
+        $this->assertEquals(0, $result);
+    }
+
+    public function testExecuteHandlesDuplicateAssignment(): void {
+        $settingClass = 'OCA\\Settings\\Settings\\Admin\\Server';
+        $groupId = 'testgroup';
+
+        // Mock valid delegated settings class
+        $this->input->expects($this->exactly(2))
+            ->method('getArgument')
+            ->willReturnMap([
+                ['settingClass', $settingClass],
+                ['groupId', $groupId]
+            ]);
+
+        // Mock group exists
+        $this->groupManager->expects($this->once())
+            ->method('groupExists')
+            ->with($groupId)
+            ->willReturn(true);
+
+        // Mock ConflictException when trying to create duplicate
+        $this->authorizedGroupService->expects($this->once())
+            ->method('create')
+            ->with($groupId, $settingClass)
+            ->willThrowException(new ConflictException('Group is already assigned to this class'));
+
+        $result = $this->command->execute($this->input, $this->output);
+
+        $this->assertEquals(4, $result, 'Duplicate assignment should return exit code 4');
+    }
+
+    public function testExecuteInvalidSettingClass(): void {
+        // Use a real class that exists but doesn't implement IDelegatedSettings
+        $settingClass = 'stdClass';
+
+        $this->input->expects($this->once())
+            ->method('getArgument')
+            ->with('settingClass')
+            ->willReturn($settingClass);
+
+        $result = $this->command->execute($this->input, $this->output);
+
+        // Should return exit code 2 for invalid setting class
+        $this->assertEquals(2, $result);
+    }
+
+    public function testExecuteNonExistentGroup(): void {
+        $settingClass = Server::class;
+        $groupId = 'nonexistentgroup';
+
+        $this->input->expects($this->exactly(2))
+            ->method('getArgument')
+            ->willReturnMap([
+                ['settingClass', $settingClass],
+                ['groupId', $groupId]
+            ]);
+
+        // Mock group does not exist
+        $this->groupManager->expects($this->once())
+            ->method('groupExists')
+            ->with($groupId)
+            ->willReturn(false);
+
+        $result = $this->command->execute($this->input, $this->output);
+
+        // Should return exit code 3 for non-existent group
+        $this->assertEquals(3, $result);
+    }
 }

apps/settings/lib/Service/AuthorizedGroupService.php

Indentation +80 added lines, -80 removed lines

@@ -16,92 +16,92 @@
 
 class AuthorizedGroupService {
 
-	public function __construct(
-		private AuthorizedGroupMapper $mapper,
-	) {
-	}
+    public function __construct(
+        private AuthorizedGroupMapper $mapper,
+    ) {
+    }
 
-	/**
-	 * @return AuthorizedGroup[]
-	 */
-	public function findAll(): array {
-		return $this->mapper->findAll();
-	}
+    /**
+     * @return AuthorizedGroup[]
+     */
+    public function findAll(): array {
+        return $this->mapper->findAll();
+    }
 
-	/**
-	 * Find AuthorizedGroup by id.
-	 *
-	 * @param int $id
-	 */
-	public function find(int $id): ?AuthorizedGroup {
-		return $this->mapper->find($id);
-	}
+    /**
+     * Find AuthorizedGroup by id.
+     *
+     * @param int $id
+     */
+    public function find(int $id): ?AuthorizedGroup {
+        return $this->mapper->find($id);
+    }
 
-	/**
-	 * @param $e
-	 * @throws NotFoundException
-	 */
-	private function handleException(\Exception $e): void {
-		if ($e instanceof DoesNotExistException
-			|| $e instanceof MultipleObjectsReturnedException) {
-			throw new NotFoundException('AuthorizedGroup not found');
-		} else {
-			throw $e;
-		}
-	}
+    /**
+     * @param $e
+     * @throws NotFoundException
+     */
+    private function handleException(\Exception $e): void {
+        if ($e instanceof DoesNotExistException
+            || $e instanceof MultipleObjectsReturnedException) {
+            throw new NotFoundException('AuthorizedGroup not found');
+        } else {
+            throw $e;
+        }
+    }
 
-	/**
-	 * Create a new AuthorizedGroup
-	 *
-	 * @param string $groupId
-	 * @param string $class
-	 * @return AuthorizedGroup
-	 * @throws Exception
-	 * @throws ConflictException
-	 */
-	public function create(string $groupId, string $class): AuthorizedGroup {
-		// Check if the group is already assigned to this class
-		try {
-			$existing = $this->mapper->findByGroupIdAndClass($groupId, $class);
-			if ($existing) {
-				throw new ConflictException('Group is already assigned to this class');
-			}
-		} catch (DoesNotExistException $e) {
-			// This is expected when no duplicate exists, continue with creation
-		}
+    /**
+     * Create a new AuthorizedGroup
+     *
+     * @param string $groupId
+     * @param string $class
+     * @return AuthorizedGroup
+     * @throws Exception
+     * @throws ConflictException
+     */
+    public function create(string $groupId, string $class): AuthorizedGroup {
+        // Check if the group is already assigned to this class
+        try {
+            $existing = $this->mapper->findByGroupIdAndClass($groupId, $class);
+            if ($existing) {
+                throw new ConflictException('Group is already assigned to this class');
+            }
+        } catch (DoesNotExistException $e) {
+            // This is expected when no duplicate exists, continue with creation
+        }
 
-		$authorizedGroup = new AuthorizedGroup();
-		$authorizedGroup->setGroupId($groupId);
-		$authorizedGroup->setClass($class);
-		return $this->mapper->insert($authorizedGroup);
-	}
+        $authorizedGroup = new AuthorizedGroup();
+        $authorizedGroup->setGroupId($groupId);
+        $authorizedGroup->setClass($class);
+        return $this->mapper->insert($authorizedGroup);
+    }
 
-	/**
-	 * @throws NotFoundException
-	 */
-	public function delete(int $id): void {
-		try {
-			$authorizedGroup = $this->mapper->find($id);
-			$this->mapper->delete($authorizedGroup);
-		} catch (\Exception $e) {
-			$this->handleException($e);
-		}
-	}
+    /**
+     * @throws NotFoundException
+     */
+    public function delete(int $id): void {
+        try {
+            $authorizedGroup = $this->mapper->find($id);
+            $this->mapper->delete($authorizedGroup);
+        } catch (\Exception $e) {
+            $this->handleException($e);
+        }
+    }
 
-	public function findExistingGroupsForClass(string $class): array {
-		try {
-			$authorizedGroup = $this->mapper->findExistingGroupsForClass($class);
-			return $authorizedGroup;
-		} catch (\Exception $e) {
-			return [];
-		}
-	}
+    public function findExistingGroupsForClass(string $class): array {
+        try {
+            $authorizedGroup = $this->mapper->findExistingGroupsForClass($class);
+            return $authorizedGroup;
+        } catch (\Exception $e) {
+            return [];
+        }
+    }
 
-	public function removeAuthorizationAssociatedTo(IGroup $group): void {
-		try {
-			$this->mapper->removeGroup($group->getGID());
-		} catch (\Exception $e) {
-			$this->handleException($e);
-		}
-	}
+    public function removeAuthorizationAssociatedTo(IGroup $group): void {
+        try {
+            $this->mapper->removeGroup($group->getGID());
+        } catch (\Exception $e) {
+            $this->handleException($e);
+        }
+    }
 }

apps/settings/lib/Command/AdminDelegation/Add.php

Indentation +37 added lines, -37 removed lines

@@ -19,47 +19,47 @@
 use Symfony\Component\Console\Style\SymfonyStyle;
 
 class Add extends Base {
-	public function __construct(
-		private IManager $settingManager,
-		private AuthorizedGroupService $authorizedGroupService,
-		private IGroupManager $groupManager,
-	) {
-		parent::__construct();
-	}
+    public function __construct(
+        private IManager $settingManager,
+        private AuthorizedGroupService $authorizedGroupService,
+        private IGroupManager $groupManager,
+    ) {
+        parent::__construct();
+    }
 
-	protected function configure(): void {
-		$this
-			->setName('admin-delegation:add')
-			->setDescription('add setting delegation to a group')
-			->addArgument('settingClass', InputArgument::REQUIRED, 'Admin setting class')
-			->addArgument('groupId', InputArgument::REQUIRED, 'Delegate to group ID')
-			->addUsage('\'OCA\Settings\Settings\Admin\Server\' mygroup')
-		;
-	}
+    protected function configure(): void {
+        $this
+            ->setName('admin-delegation:add')
+            ->setDescription('add setting delegation to a group')
+            ->addArgument('settingClass', InputArgument::REQUIRED, 'Admin setting class')
+            ->addArgument('groupId', InputArgument::REQUIRED, 'Delegate to group ID')
+            ->addUsage('\'OCA\Settings\Settings\Admin\Server\' mygroup')
+        ;
+    }
 
-	public function execute(InputInterface $input, OutputInterface $output): int {
-		$io = new SymfonyStyle($input, $output);
-		$settingClass = $input->getArgument('settingClass');
-		if (!in_array(IDelegatedSettings::class, (array)class_implements($settingClass), true)) {
-			$io->error('The specified class isn’t a valid delegated setting.');
-			return 2;
-		}
+    public function execute(InputInterface $input, OutputInterface $output): int {
+        $io = new SymfonyStyle($input, $output);
+        $settingClass = $input->getArgument('settingClass');
+        if (!in_array(IDelegatedSettings::class, (array)class_implements($settingClass), true)) {
+            $io->error('The specified class isn’t a valid delegated setting.');
+            return 2;
+        }
 
-		$groupId = $input->getArgument('groupId');
-		if (!$this->groupManager->groupExists($groupId)) {
-			$io->error('The specified group didn’t exist.');
-			return 3;
-		}
+        $groupId = $input->getArgument('groupId');
+        if (!$this->groupManager->groupExists($groupId)) {
+            $io->error('The specified group didn’t exist.');
+            return 3;
+        }
 
-		try {
-			$this->authorizedGroupService->create($groupId, $settingClass);
-		} catch (ConflictException) {
-			$io->warning('Administration of ' . $settingClass . ' is already delegated to ' . $groupId . '.');
-			return 4;
-		}
+        try {
+            $this->authorizedGroupService->create($groupId, $settingClass);
+        } catch (ConflictException) {
+            $io->warning('Administration of ' . $settingClass . ' is already delegated to ' . $groupId . '.');
+            return 4;
+        }
 
-		$io->success('Administration of ' . $settingClass . ' delegated to ' . $groupId . '.');
+        $io->success('Administration of ' . $settingClass . ' delegated to ' . $groupId . '.');
 
-		return 0;
-	}
+        return 0;
+    }
 }