<?php
/**
 * Test methods for the P4 Group class.
 *
 * @copyright   2012 Perforce Software. All rights reserved.
 * @license     Please see LICENSE.txt in top-level folder of this distribution.
 * @version     <release>/<patch>
 */
 
namespace P4Test\Spec;
 
use P4Test\TestCase;
use P4\Spec\User;
use P4\Spec\Group;
use P4\Connection\Connection;
use P4\Spec\Exception\NotFoundException;
use P4\Spec\Exception\Exception as SpecException;
 
class GroupTest extends TestCase
{
    /**
     * Test fetchAll method
     */
    public function testFetchAll()
    {
        $group = new Group;
        $group->setId('test1')->addUser('user1')->save();
        $group = new Group;
        $group->setId('test2')->addUser('user1')->save();
        $group = new Group;
        $group->setId('test3')->addUser('user2')->addSubgroup('test2')->save();
        $group = new Group;
        $group->setId('test4')->addUser('user3')->addSubgroup('test3')->save();
        $group = new Group;
        $group->setId('test5')->addUser('user4')->addOwner('user5')->save();
        $group = new Group;
        $group->setId('test6')->addSubgroup('test7')->save();
        $group = new Group;
        $group->setId('test7%%')
              ->addSubgroup('test%%7')
              ->addUser('user1')
              ->addUser('user%%1')
              ->addOwner('user%%2')
              ->save();
        $names = array('test1', 'test2', 'test3', 'test4', 'test5', 'test6', 'test7%%');
 
        // Verify full fetchAll works ok
        $this->assertSame(
            $names,
            Group::fetchAll()->invoke('getId'),
            'Expected fetch all to match'
        );
 
        // Verify fetch with made up option works
        $this->assertSame(
            $names,
            Group::fetchAll(
                array('fooBar' => true)
            )->invoke('getId'),
            'Expected fetch all with made up option to match'
        );
 
        // Verify full FETCH_MAXIMUM works
        $this->assertSame(
            array_slice($names, 0, 3),
            Group::fetchAll(
                array(Group::FETCH_MAXIMUM => '3')
            )->invoke('getId'),
            'Expected fetch all with Maximum to match'
        );
 
        // Verify full FETCH_BY_MEMBER works for users
        $expected = array_slice($names, 0, 2);
        $expected[] = $names[6];
        $this->assertSame(
            $expected,
            Group::fetchAll(
                array(Group::FETCH_BY_MEMBER => 'user1')
            )->invoke('getId'),
            'Expected fetch all with member filter to match'
        );
 
        // Verify full FETCH_BY_MEMBER works for users with position specifiers
        $this->assertSame(
            array('test7%%'),
            Group::fetchAll(
                array(Group::FETCH_BY_MEMBER => 'user%%1')
            )->invoke('getId'),
            'Expected fetch all with member %% filter to match'
        );
 
        // Verify full FETCH_BY_MEMBER works for groups
        $this->assertSame(
            (array)'test6',
            Group::fetchAll(
                array(Group::FETCH_BY_MEMBER => 'test7')
            )->invoke('getId'),
            'Expected fetch all with sub-group member filter to match'
        );
 
        // Verify full FETCH_BY_MEMBER works for groups with position specifiers
        $this->assertSame(
            (array)'test7%%',
            Group::fetchAll(
                array(Group::FETCH_BY_MEMBER => 'test%%7')
            )->invoke('getId'),
            'Expected fetch all with sub-group member %% filter to match'
        );
 
        // Verify full FETCH_BY_MEMBER works for owners
        $this->assertSame(
            (array)'test5',
            Group::fetchAll(
                array(Group::FETCH_BY_MEMBER => 'user5')
            )->invoke('getId'),
            'Expected fetch all with owner member filter to match'
        );
 
        // Verify full FETCH_BY_MEMBER works for owners with position specifiers
        $this->assertSame(
            (array)'test7%%',
            Group::fetchAll(
                array(Group::FETCH_BY_MEMBER => 'user%%2')
            )->invoke('getId'),
            'Expected fetch all with owner member %% filter to match'
        );
 
        // Verify full FETCH_BY_MEMBER with FETCH_INDIRECT works
        $expected = array_slice($names, 0, 4);
        $expected[] = $names[6];
        $this->assertSame(
            $expected,
            Group::fetchAll(
                array(
                    Group::FETCH_BY_MEMBER   => 'user1',
                    Group::FETCH_INDIRECT    => true
                )
            )->invoke('getId'),
            'Expected fetch all with indirect member filter to match'
        );
 
        // Verify full FETCH_BY_MEMBER with FETCH_INDIRECT and FETCH_MAXIMUM works
        $this->assertSame(
            array_slice($names, 0, 2),
            Group::fetchAll(
                array(
                    Group::FETCH_BY_MEMBER   => 'user1',
                    Group::FETCH_INDIRECT    => true,
                    Group::FETCH_MAXIMUM     => 2
                )
            )->invoke('getId'),
            'Expected fetch all with indirect member filter and maximum to match'
        );
 
        // Verify FETCH_BY_USER works
        $this->assertSame(
            array('test1', 'test2', 'test7%%'),
            Group::fetchAll(
                array(
                     Group::FETCH_BY_USER     => 'user1',
                )
            )->invoke('getId'),
            'expected simple fetch by user to work'
        );
 
        // Verify FETCH_BY_USER works with FETCH_INDIRECT
        $this->assertSame(
            array('test1', 'test2', 'test3', 'test4', 'test7%%'),
            Group::fetchAll(
                array(
                     Group::FETCH_BY_USER     => 'user1',
                     Group::FETCH_INDIRECT    => true
                )
            )->invoke('getId'),
            'expected indirect fetch by user to work'
        );
 
        // Verify FETCH_BY_USER doesn't cover sub-groups
        $this->assertSame(
            array(),
            Group::fetchAll(
                array(
                     Group::FETCH_BY_USER     => 'test2',
                     Group::FETCH_INDIRECT    => true
                )
            )->invoke('getId'),
            'expected fetch by user to ignore groups'
        );
 
        // Verify full FETCH_BY_NAME works
        $this->assertSame(
            array_slice($names, 0, 1),
            Group::fetchAll(
                array(Group::FETCH_BY_NAME => 'test1')
            )->invoke('getId'),
            'Expected fetch all with name filter to match'
        );
        // Verify full FETCH_BY_NAME works with position specifiers
        $this->assertSame(
            array($names[6]),
            Group::fetchAll(
                array(Group::FETCH_BY_NAME => 'test7%%')
            )->invoke('getId'),
            'Expected fetch all with name %% filter to match'
        );
    }
 
    /**
     * Test groups specs returned by fetchAll
     */
    public function testFetchAllSpecs()
    {
        $group = new Group;
        $group->setId('test1')
              ->addSubgroup('sg1')
              ->addUser('user1')
              ->addUser('user2')
              ->addUser('user3')
              ->addOwner('user0')
              ->save();
 
        $result = Group::fetchAll();
        $this->assertSame(
            1,
            $result->count(),
            "Expected fetch all returns 1 result"
        );
 
        // prepare expected spec values
        $expectedUsers     = array('user1', 'user2', 'user3');
        $expectedOwners    = array('user0');
        $expectedSubgroups = array('sg1');
 
        // Verify result contains correct spec
        $group = $result->current();
        $this->assertSame(
            $expectedUsers,
            $group->getUsers(),
            "Expected fetch all users spec"
        );
        $this->assertSame(
            $expectedSubgroups,
            $group->getSubgroups(),
            "Expected fetch all subgroups spec"
        );
        $this->assertSame(
            $expectedOwners,
            $group->getOwners(),
            "Expected fetch all owners spec"
        );
 
        // Verify result contains correct specs for filter by name
        $result = Group::fetchAll(
            array(Group::FETCH_BY_NAME => 'test1')
        );
        $this->assertSame(
            1,
            $result->count(),
            "Expected fetch all #2 returns 1 result"
        );
 
        // Verify result contains correct spec
        $group = $result->current();
        $this->assertSame(
            $expectedUsers,
            $group->getUsers(),
            "Expected fetch all #2 users spec"
        );
        $this->assertSame(
            $expectedSubgroups,
            $group->getSubgroups(),
            "Expected fetch all #2 subgroups spec"
        );
        $this->assertSame(
            $expectedOwners,
            $group->getOwners(),
            "Expected fetch all #2 owners spec"
        );
 
        // Verify result contains correct specs for filter by member
        $result = Group::fetchAll(
            array(Group::FETCH_BY_MEMBER => 'user2')
        );
        $this->assertSame(
            1,
            $result->count(),
            "Expected fetch all #3 returns 1 result"
        );
 
        // Verify result contains correct spec
        $group = $result->current();
        $this->assertSame(
            $expectedUsers,
            $group->getUsers(),
            "Expected fetch all #3 users spec"
        );
        $this->assertSame(
            $expectedSubgroups,
            $group->getSubgroups(),
            "Expected fetch all #3 subgroups spec"
        );
        $this->assertSame(
            $expectedOwners,
            $group->getOwners(),
            "Expected fetch all #3 owners spec"
        );
 
        // Verify that saving partialy altered and unpopulated spec will save all values
        $group = Group::fetchAll(
            array(Group::FETCH_BY_MEMBER => 'user2')
        )->current();
 
        $group->setUsers(array('user4'))
              ->save();
 
        // Verify result contains correct spec
        $group = Group::fetch('test1');
        $this->assertSame(
            array('user4'),
            $group->getUsers(),
            "Expected fetch all #4 users spec"
        );
        $this->assertSame(
            $expectedSubgroups,
            $group->getSubgroups(),
            "Expected fetch all #4 subgroups spec"
        );
        $this->assertSame(
            $expectedOwners,
            $group->getOwners(),
            "Expected fetch all #4 owners spec"
        );
    }
 
    /**
     * Tests invalid options and option combos
     */
    public function testFetchAllBadOptions()
    {
        $tests = array(
            array(
                'title'     => __LINE__.' integer name filter',
                'options'   => array(Group::FETCH_BY_NAME => 0),
                'exception' => 'Filter by Name expects a valid group id.'
            ),
            array(
                'title'     => __LINE__.' empty string name filter',
                'options'   => array(Group::FETCH_BY_NAME => ""),
                'exception' => 'Filter by Name expects a valid group id.'
            ),
            array(
                'title'     => __LINE__.' invalid name filter',
                'options'   => array(Group::FETCH_BY_NAME => "-test"),
                'exception' => 'Filter by Name expects a valid group id.'
            ),
            array(
                'title'     => __LINE__.' name filter with indirect option',
                'options'   =>  array(
                                    Group::FETCH_BY_NAME => "test",
                                    Group::FETCH_INDIRECT => true
                                ),
                'exception' => 'Filter by Name is not compatible with Fetch by Member or Fetch Indirect.'
            ),
            array(
                'title'     => __LINE__.' name filter with member option',
                'options'   =>  array(
                                    Group::FETCH_BY_NAME => "test",
                                    Group::FETCH_BY_MEMBER => "user"
                                ),
                'exception' => 'Filter by Name is not compatible with Fetch by Member or Fetch Indirect.'
            ),
            array(
                'title'     => __LINE__.' name filter with indirect and member options',
                'options'   =>  array(
                                    Group::FETCH_BY_NAME => "test",
                                    Group::FETCH_BY_MEMBER => "user",
                                    Group::FETCH_INDIRECT => true,
                                ),
                'exception' => 'Filter by Name is not compatible with Fetch by Member or Fetch Indirect.'
            ),
            array(
                'title'     => __LINE__.' empty string member filter',
                'options'   => array(Group::FETCH_BY_MEMBER => ""),
                'exception' => 'Filter by Member expects a valid group or username.'
            ),
            array(
                'title'     => __LINE__.' integer member filter',
                'options'   => array(Group::FETCH_BY_MEMBER => 10),
                'exception' => 'Filter by Member expects a valid group or username.'
            ),
            array(
                'title'     => __LINE__.' invalid member filter',
                'options'   => array(Group::FETCH_BY_MEMBER => "-test"),
                'exception' => 'Filter by Member expects a valid group or username.'
            ),
        );
 
        foreach ($tests as $test) {
            try {
                Group::fetchAll($test['options']);
 
                $this->fail($test['title'].': unexpected success');
            } catch (\PHPUnit\Framework\AssertionFailedError $e) {
                $this->fail($e->getMessage());
            } catch (\InvalidArgumentException $e) {
                $this->assertSame(
                    $test['exception'],
                    $e->getMessage(),
                    $test['title'].': unexpected exception message'
                );
            } catch (\Exception $e) {
                $this->fail(
                    $test['title'].
                    ': unexpected exception ('. get_class($e) .') '.
                    $e->getMessage()
                );
            }
        }
    }
 
    /**
     * Test calling save without an ID
     */
    public function testSaveNoId()
    {
        try {
            $group = new Group;
            $group->save();
 
            $this->fail('unexpected success');
        } catch (\PHPUnit\Framework\AssertionFailedError $e) {
            $this->fail($e->getMessage());
        } catch (SpecException $e) {
            $this->assertSame(
                'Cannot save. Group is empty.',
                $e->getMessage(),
                'unexpected exception message'
            );
        } catch (\Exception $e) {
            $this->fail(': unexpected exception ('. get_class($e) .') '. $e->getMessage());
        }
    }
 
    /**
     * Test fetch
     */
    public function testFetch()
    {
        // ensure fetch fails for a non-existant group.
        try {
            Group::fetch('alskdfj2134');
            $this->fail("Fetch should fail for a non-existant group.");
        } catch (NotFoundException $e) {
            $this->assertTrue(true);
        }
 
        // ensure fetch works for a just-created group
        $group = new Group;
        $group->setId('testers%%')
              ->addUser('tester')
              ->save();
 
        $group = Group::fetch('testers%%');
        $this->assertTrue($group->getId() == 'testers%%', "User id should be 'testers%%'.");
    }
 
    /**
     * Test id exists
     */
    public function testIdExists()
    {
        // ensure id-exists returns false for ill formatted group
        $this->assertFalse(Group::exists("-alsdjf"), "Invalid group id should not exist.");
 
        // ensure id-exists returns false for non-existant group
        $this->assertFalse(Group::exists("alsdjf"), "Given group id should not exist.");
 
        // create group and ensure it exists.
        $group = new Group;
        $group->setId('test')
              ->addUser('tester')
              ->save();
        $this->assertTrue(Group::exists("test"), 'Given group id should exist.');
 
        // check a group that contains position specifiers
        $group = new Group;
        $group->setId('testers%%')
              ->addUser('tester')
              ->save();
        $this->assertTrue(Group::exists('testers%%'), 'Given group id should exist.');
    }
 
    /**
     * test is empty
     */
    public function testIsEmpty()
    {
        $group = new Group;
        $this->assertTrue(
            $group->isEmpty(),
            'Expected fresh group to be empty'
        );
 
        $group = new Group;
        $this->assertTrue(
            $group->setId('test')->isEmpty(),
            'Expected group with ID to be empty'
        );
 
        $group = new Group;
        $this->assertTrue(
            $group->setId('test%%')->isEmpty(),
            'Expected group with ID %% to be empty'
        );
 
        $group = new Group;
        $this->assertTrue(
            $group->setTimeout(100)->isEmpty(),
            'Expected group with timeout to be empty'
        );
 
        $group = new Group;
        $this->assertFalse(
            $group->addSubgroup('test')->isEmpty(),
            'Expected group with subgroup to not be empty'
        );
 
        $group = new Group;
        $this->assertFalse(
            $group->addOwner('test')->isEmpty(),
            'Expected group with owner to not be empty'
        );
 
        $group = new Group;
        $this->assertFalse(
            $group->addUser('test')->isEmpty(),
            'Expected group with user to not be empty'
        );
    }
 
    /**
     * test 'max' style fields with bad values
     */
    public function testBadMaxResultsMaxScanRowsMaxLockTimeTimeout()
    {
        $methods = array('MaxResults', 'MaxScanRows', 'MaxLockTime', 'Timeout');
        $tests = array(
            array(
                'title' => __LINE__.' bool',
                'value' => true,
                'error' => 'Type of input must be one of: null, int, string'
            ),
            array(
                'title' => __LINE__.' unsets',
                'value' => 'unsets',
                'error' => "For string input, only the values 'unlimited' and 'unset' are valid."
            ),
            array(
                'title' => __LINE__.' blank string',
                'value' => '',
                'error' => "For string input, only the values 'unlimited' and 'unset' are valid."
            ),
            array(
                'title' => __LINE__.' small negative number',
                'value' => -2,
                'error' => 'For integer input, only values greater than zero are valid.'
            ),
            array(
                'title' => __LINE__.' big negative number',
                'value' => -20000,
                'error' => 'For integer input, only values greater than zero are valid.'
            )
        );
 
        foreach ($methods as $method) {
            foreach ($tests as $test) {
                $group = new Group;
 
                try {
                    $group->{'set'.$method}($test['value']);
 
                    $this->fail($test['title'].', '. $method .': unexpected success');
                } catch (\PHPUnit\Framework\AssertionFailedError $e) {
                    $this->fail($e->getMessage());
                } catch (\InvalidArgumentException $e) {
                    $this->assertSame(
                        $test['error'],
                        $e->getMessage(),
                        $test['title'].', '. $method .': unexpected exception message'
                    );
                } catch (\Exception $e) {
                    $this->fail(
                        $test['title'].', '. $method .
                        ': unexpected exception ('. get_class($e) .') '.
                        $e->getMessage()
                    );
                }
            }
        }
    }
 
    /**
     * test 'max' style fields with good values
     */
    public function testGoodMaxResultsMaxScanRowsMaxLockTimeTimeout()
    {
        $methods = array('MaxResults', 'MaxScanRows', 'MaxLockTime', 'Timeout');
        $tests = array(
            array(
                'title' => __LINE__.' small int',
                'value' => 1,
            ),
            array(
                'title' => __LINE__.' big int',
                'value' => 10000,
            ),
            array(
                'title' => __LINE__.' unset',
                'value' => 'unset',
                'out'   => null
            ),
            array(
                'title' => __LINE__.' null',
                'value' => null,
            ),
            array(
                'title' => __LINE__.' unlimited',
                'value' => 'unlimited',
            ),
        );
 
        foreach ($methods as $method) {
            foreach ($tests as $test) {
                $group = new Group;
 
                $group->setId('test')->addUser('test');
                $group->{'set'.$method}($test['value']);
 
                $out = array_key_exists('out', $test) ? $test['out'] : $test['value'];
 
                // verify in-memory object matches up
                $this->assertSame(
                    $out,
                    $group->{'get'.$method}(),
                    $test['title'].', '. $method .': expected matching return'
                );
 
                // save and verify it still matches
                $group->save();
                $this->assertSame(
                    $out,
                    $group->{'get'.$method}(),
                    $test['title'].', '. $method .': expected matching return post save'
                );
 
                // fetch from storage and verify it still matches
                $group = Group::fetch('test');
                $this->assertSame(
                    $out,
                    $group->{'get'.$method}(),
                    $test['title'].', '. $method .': expected matching return on fetched version'
                );
 
            }
        }
    }
 
    /**
     * Test behaviour when bad subgroups, owners, and users are specified.
     */
    public function testBadSubgroupsOwnersUsers()
    {
        $methods = array(
            'setSubgroups', 'addSubgroup',
            'setOwners',    'addOwner',
            'setUsers',     'addUser',
        );
        $arrayError   = '/^[^ ]+ must be specified as an array.$/';
        $elementError = '/^Individual [^ ]+ must be a valid ID in either string or [^ ]+ format.$/';
        $tests = array(
            array(
                'title' => __LINE__.' int',
                'value' => 10,
                'setError' => $arrayError,
                'addError' => $elementError
            ),
            array(
                'title' => __LINE__.' bool',
                'value' => true,
                'setError' => $arrayError,
                'addError' => $elementError
            ),
            array(
                'title' => __LINE__.' null',
                'value' => null,
                'setError' => $arrayError,
                'addError' => $elementError
            ),
            array(
                'title' => __LINE__.' array of ints',
                'value' => array(10, 9, 8),
                'setError' => $elementError,
                'addError' => $elementError
            ),
        );
 
 
        foreach ($methods as $method) {
            foreach ($tests as $test) {
                $group = new Group;
 
                try {
                    $group->{$method}($test['value']);
 
                    $this->fail($test['title'].', '. $method .': unexpected success');
                } catch (\PHPUnit\Framework\AssertionFailedError $e) {
                    $this->fail($e->getMessage());
                } catch (\InvalidArgumentException $e) {
                    $error = $test[substr($method, 0, 3).'Error'];
                    $this->assertRegExp(
                        $error,
                        $e->getMessage(),
                        $test['title'].', '. $method .': unexpected exception message'
                    );
                } catch (\Exception $e) {
                    $this->fail(
                        $test['title'].', '. $method .
                        ': unexpected exception ('. get_class($e) .') '.
                        $e->getMessage()
                    );
                }
            }
        }
    }
 
    /**
     * Test good set/add Subgroups, Owners, Users
     */
    public function testGoodSubgroupsOwnersUsers()
    {
        $group = new Group;
        $group->setId('test');
        $user = new User;
        $user->setId('test');
 
        $methods = array(
            'Subgroup' => $group,
            'Owner'    => $user,
            'User'     => $user,
        );
 
        try {
            foreach ($methods as $method => $object) {
                // test 'set'
                $group = new Group;
                $group->setId('test');
                $group->{'set'.$method.'s'}(array($object));
 
                $this->assertSame(
                    (array)$object->getId(),
                    $group->{'get'.$method.'s'}(),
                    $method.': expected matching return following set'
                );
 
                // test 'add'
                $group->{'add'.$method}('test2');
                $this->assertSame(
                    array('test', 'test2'),
                    $group->{'get'.$method.'s'}(),
                    $method.': expected matching return following add'
                );
 
                // save and verify it still matches
                $group->save();
                $this->assertSame(
                    array('test', 'test2'),
                    $group->{'get'.$method.'s'}(),
                    $method.': expected matching return following save'
                );
 
                // fetch from storage and verify it still matches
                $group = Group::fetch('test');
                $this->assertSame(
                    array('test', 'test2'),
                    $group->{'get'.$method.'s'}(),
                    $method.': expected matching return following fetch'
                );
            }
        } catch (\PHPUnit\Framework\AssertionFailedError $e) {
            $this->fail($e->getMessage());
        } catch (\Exception $e) {
            $this->fail(
                $method.': unexpected exception ('. get_class($e) .') '. $e->getMessage()
            );
        }
    }
 
    /**
     * Test save as owner.
     */
    public function testSaveAsOwner()
    {
        $user = new User;
        $user->setId('owner-user')
             ->setFullName('Owner Of Group')
             ->setEmail('owner@domain.com')
             ->save();
 
        $group = new Group;
        $group->setId('test-group')
              ->setUsers(array($user->getId()))
              ->setOwners(array($user->getId()))
              ->save();
 
        // connect as 'owner-user'.
        $connection = Connection::factory(
            $this->p4->getPort(),
            $user->getId()
        );
 
        // save of group should fail w.out owner flag.
        try {
            $group = Group::fetch('test-group', $connection);
            $group->save();
            $this->fail('unexpected success');
        } catch (\Exception $e) {
            $this->assertTrue(true);
        }
 
        // now try to save the test-group w. owner flag.
        $group = Group::fetch('test-group', $connection);
        $group->save(true);
    }
 
    /**
     * Test fetch all captures all values (we had a bug where some fields were dropped).
     */
    public function testFetchAllGetsAllFields()
    {
        $values = array(
            'Group'             => 'test-group',
            'MaxResults'        => 1000,
            'MaxScanRows'       => 10000,
            'MaxLockTime'       => 30000,
            'Timeout'           => 3600,
            'PasswordTimeout'   => 'unlimited',
            'Subgroups'         => array('sub-group'),
            'Owners'            => array('tester'),
            'Users'             => array('tester')
        );
        $this->p4->run('group', array('-i'), $values);
 
        $groups = Group::fetchAll(array(), $this->p4);
        $this->assertSame(
            array('test-group' => $values),
            $groups->toArray()
        );
    }
 
    /**
     * Test fetch all with a filter callback
     */
    public function testFetchAllWithCallback()
    {
        for ($i = 0; $i < 10; $i++) {
            $this->p4->run('group', array('-i'), array('Group' => 'group' . $i, 'Owners' => array('tester')));
        }
 
        $groups = Group::fetchAll();
        $this->assertSame(10, $groups->count());
 
        $groups = Group::fetchAll(
            array(Group::FETCH_FILTER_CALLBACK => function ($group) {
                return filter_var($group['Group'], FILTER_SANITIZE_NUMBER_INT) % 2;
            })
        );
        $this->assertSame(5, $groups->count());
        $this->assertSame(array('group1', 'group3', 'group5', 'group7', 'group9'), $groups->invoke('getId'));
    }
}