Untitled

package
 {
        public class UserDataVOFilterTest extends TestCase {
                private var instance:UserDataVOFilter;
                protected var dataSet:Vector.<UserDataVO>;

                public function UserDataVOFilterTest(methodName:String=null) {
                        super(methodName);
                }

                override protected function setUp():void {
                        super.setUp();
                        dataSet = new Vector.<UserDataVO>();
                        instance = new UserDataVOFilter(dataSet);
                }

                override protected function tearDown():void {
                        super.tearDown();
                        instance = null;
                }

                public function testInstantiated():void {
                        assertTrue("instance is UserDataVOFilter", instance is UserDataVOFilter);
                }

                public function test_implements_interface():void {
                        assertTrue("Implements interface", instance is IUserDataVOFilter);
                }

                public function testFailure():void {
                        assertTrue("Failing test", true);
                }

                public function test_filters_by_company_key():void {
                        dataSet.push(new UserDataVOSupport(1));
                        dataSet.push(new UserDataVOSupport(2));
                        dataSet.push(new UserDataVOSupport(3));
                        //from Support: var companyID:uint = userKey+2;

                        var filteredData:Vector.<UserDataVO> = instance.withCompanyKey(4).data;
                        assertEqualsVectorsIgnoringOrder('filtered by company key', Vector.<UserDataVO>([dataSet[1]]), filteredData);
                }

                public function test_filters_by_office_key():void {
                        dataSet.push(new UserDataVOSupport(1));
                        dataSet.push(new UserDataVOSupport(2));
                        dataSet.push(new UserDataVOSupport(3));
                        //from Support: var officeID:uint = userKey+1;

                        var filteredData:Vector.<UserDataVO> = instance.withOfficeKey(3).data;
                        assertEqualsVectorsIgnoringOrder('filtered by office key', Vector.<UserDataVO>([dataSet[1]]), filteredData);
                }

                public function test_filters_by_user_status_key():void {
                        dataSet.push(new UserDataVOSupport(1));
                        dataSet.push(new UserDataVOSupport(2));
                        dataSet.push(new UserDataVOSupport(3));
                        //from Support: var userStatusID:uint = userKey+1;

                        var filteredData:Vector.<UserDataVO> = instance.withStatus(3).data;
                        assertEqualsVectorsIgnoringOrder('filtered by userstatus key', Vector.<UserDataVO>([dataSet[1]]), filteredData);
                }

                public function test_filters_by_mananger():void {
                        dataSet.push( createManager(1) );
                        dataSet.push( createStudent(2) );
                        dataSet.push( createManager(3) );

                        var filteredData:Vector.<UserDataVO> = instance.onlyManagers().data;
                        assertEqualsVectorsIgnoringOrder('filtered by manager', Vector.<UserDataVO>([dataSet[0], dataSet[2]]), filteredData);
                }

                public function test_filters_by_admin():void {
                        dataSet.push( createAdmin(1) );
                        dataSet.push( createStudent(2) );
                        dataSet.push( createAdmin(3) );

                        var filteredData:Vector.<UserDataVO> = instance.onlyAdmin().data;
                        assertEqualsVectorsIgnoringOrder('filtered by admin', Vector.<UserDataVO>([dataSet[0], dataSet[2]]), filteredData);
                }

                public function test_filters_managers_and_admin():void {
                        dataSet.push( createManager(1) );
                        dataSet.push( createStudent(2) );
                        dataSet.push( createAdmin(3) );

                        var filteredData:Vector.<UserDataVO> = instance.managersAndAdmin().data;
                        assertEqualsVectorsIgnoringOrder('filtered to admin and managers', Vector.<UserDataVO>([dataSet[0], dataSet[2]]), filteredData);
                }

                public function test_students_only():void {
                        dataSet.push( createManager(1) );
                        dataSet.push( createStudent(2) );
                        dataSet.push( createAdmin(3) );
                        dataSet.push( createStudent(6) );

                        var filteredData:Vector.<UserDataVO> = instance.onlyStudents().data;
                        assertEqualsVectorsIgnoringOrder('filtered to admin and managers', Vector.<UserDataVO>([dataSet[1], dataSet[3]]), filteredData);
                }

                protected function createManager(key:uint):UserDataVO
                {
                        var manager:UserDataVOSupport = new UserDataVOSupport(key)
                        manager.changeProperty('isManager', true);
                        return manager;
                }

                protected function createAdmin(key:uint):UserDataVO
                {
                        var admin:UserDataVOSupport = new UserDataVOSupport(key)
                        admin.changeProperty('isAdmin', true);
                        return admin;
                }

                protected function createStudent(key:uint):UserDataVO
                {
                        var student:UserDataVOSupport = new UserDataVOSupport(key);
                        return student;
                }
        }
}