public function testRemoveUser() { // Get a contest $contestData = ContestsFactory::createContest(); // Create a user $user = UserFactory::createUser(); // Add user to contest ContestsFactory::addUser($contestData, $user); // Validate 0 users $r = new Request(); $r['contest_alias'] = $contestData['request']['alias']; $r['auth_token'] = $this->login($contestData['director']); $response = ContestController::apiUsers($r); $this->assertEquals(1, count($response['users'])); // Remove user $r = new Request(); $r['contest_alias'] = $contestData['request']['alias']; $r['usernameOrEmail'] = $user->getUsername(); $r['auth_token'] = $this->login($contestData['director']); ContestController::apiRemoveUser($r); // Validate 0 users in contest $r = new Request(); $r['contest_alias'] = $contestData['request']['alias']; $r['auth_token'] = $this->login($contestData['director']); $response = ContestController::apiUsers($r); $this->assertEquals(0, count($response['users'])); }
public function testContestUsersValid() { // Get a contest $contestData = ContestsFactory::createContest(); // Create 10 users $n = 10; $users = array(); for ($i = 0; $i < $n; $i++) { // Create a user $users[$i] = UserFactory::createUser(); // Add it to the contest ContestsFactory::addUser($contestData, $users[$i]); } // Create a n+1 user who will just join to the contest withot being // added via API. For public contests, by entering to the contest, the user should be in // the list of contest's users. $nonRegisteredUser = UserFactory::createUser(); ContestsFactory::openContest($contestData, $nonRegisteredUser); // Prepare request $r = new Request(); $r["contest_alias"] = $contestData["request"]["alias"]; // Log in with the admin of the contest $r["auth_token"] = $this->login($contestData["director"]); // Call API $response = ContestController::apiUsers($r); // Check that we have n+1 users $this->assertEquals($n + 1, count($response["users"])); }
/** * Contestant submits runs and admin is able to get them */ public function testGetRunsForContest() { // Get a problem $problemData = ProblemsFactory::createProblem(); // Get a contest $contestData = ContestsFactory::createContest(); // Add the problem to the contest ContestsFactory::addProblemToContest($problemData, $contestData); // Create our contestant $contestant = UserFactory::createUser(); // Create a run $runData = RunsFactory::createRun($problemData, $contestData, $contestant); // Grade the run RunsFactory::gradeRun($runData); // Create request $r = new Request(); $r["contest_alias"] = $contestData["request"]["alias"]; $r["auth_token"] = $this->login($contestData["director"]); // Call API $response = ContestController::apiRuns($r); // Assert $this->assertEquals(1, count($response["runs"])); $this->assertEquals($runData["response"]["guid"], $response["runs"][0]["guid"]); $this->assertEquals($contestant->username, $response["runs"][0]["username"]); $this->assertEquals("J1", $response["runs"][0]["judged_by"]); }
/** * Checks that, if there's no wait time, 0 is posted in max_wait_time */ public function testGetStatsNoWaitTime() { // Get a problem $problemData = ProblemsFactory::createProblem(); // Get a contest $contestData = ContestsFactory::createContest(); // Add the problem to the contest ContestsFactory::addProblemToContest($problemData, $contestData); // Create our contestant $contestant = UserFactory::createUser(); $ACRunsCount = 2; $ACRunsData = array(); for ($i = 0; $i < $ACRunsCount; $i++) { $ACRunsData[$i] = RunsFactory::createRun($problemData, $contestData, $contestant); // Grade the run RunsFactory::gradeRun($ACRunsData[$i]); } // Create request $r = new Request(); $r['contest_alias'] = $contestData['request']['alias']; $r['auth_token'] = $this->login($contestData['director']); // Call API $response = ContestController::apiStats($r); // Check number of pending runs $this->assertEquals($ACRunsCount, $response['total_runs']); $this->assertEquals(0, $response['max_wait_time']); $this->assertEquals(0, $response['max_wait_time_guid']); }
public function testEditContest() { // Login $author = $this->createUserAndLogin(); // Create a problem $contestData = ContestsFactory::createContest(null, 1, $author); // Open problem create $this->open('/contestedit.php'); sleep(1); $this->type('name=contests', $contestData["request"]["alias"]); $this->waitForValue('name=title', $contestData["request"]["title"]); $contestData["request"]["title"] = "new title"; $contestData["request"]["description"] = "new description"; $contestData["request"]["public"] = 0; $this->type('name=title', $contestData["request"]["title"]); $this->type('name=description', $contestData["request"]["description"]); $this->type('name=public', $contestData["request"]["public"]); // Click inicia sesion $this->click("//input[@value='Actualizar concurso']"); $this->waitForElementPresent('id=status'); sleep(1); $this->assertElementContainsText('//*[@id="content"]/div[2]/div', "Tu concurso ha sido editado!"); // Check DB values $v = new OmegaupTestCase(); $v->assertContest($contestData["request"]); }
/** * Creates a valid clarification */ public function testCreateValidClarification() { // Get a problem $problemData = ProblemsFactory::createProblem(); // Get a contest $contestData = ContestsFactory::createContest(); // Add the problem to the contest ContestsFactory::addProblemToContest($problemData, $contestData); // Create our contestant who will submit the clarification $contestant = UserFactory::createUser(); // Call the API $this->detourBroadcasterCalls(); $clarificationData = ClarificationsFactory::createClarification($problemData, $contestData, $contestant); // Assert status of new contest $this->assertArrayHasKey("clarification_id", $clarificationData['response']); // Verify that clarification was inserted in the database $clarification = ClarificationsDAO::getByPK($clarificationData['response']['clarification_id']); // Verify our retreived clarificatoin $this->assertNotNull($clarification); $this->assertEquals($clarificationData['request']['message'], $clarification->getMessage()); // We need to verify that the contest and problem IDs where properly saved // Extractiing the contest and problem from DB to check IDs $problem = ProblemsDAO::getByAlias($problemData["request"]["alias"]); $contest = ContestsDAO::getByAlias($contestData["request"]["alias"]); $this->assertEquals($contest->getContestId(), $clarification->getContestId()); $this->assertEquals($problem->getProblemId(), $clarification->getProblemId()); }
public function testUpdateProblemTitleAndContents() { // Get a problem $problemData = ProblemsFactory::createProblem(); // Get a contest $contestData = ContestsFactory::createContest(); // Add the problem to the contest ContestsFactory::addProblemToContest($problemData, $contestData); // Create our contestant $contestant = UserFactory::createUser(); // Create a run $runData[0] = RunsFactory::createRun($problemData, $contestData, $contestant); $runData[1] = RunsFactory::createRun($problemData, $contestData, $contestant); // Grade the run RunsFactory::gradeRun($runData[0]); RunsFactory::gradeRun($runData[1]); // Get File Uploader Mock and tell Omegaup API to use it FileHandler::SetFileUploader($this->createFileUploaderMock()); // Update Problem calls grader to rejudge, we need to detour grader calls // We will submit 2 runs to the problem, a call to grader to rejudge them $this->detourGraderCalls($this->exactly(1)); // Prepare request $r = new Request(); $r['title'] = 'new title'; $r['time_limit'] = 12345; $r['problem_alias'] = $problemData['request']['alias']; $r['stack_limit'] = 12345; $r['message'] = 'Changed some properties'; // Set file upload context $_FILES['problem_contents']['tmp_name'] = OMEGAUP_RESOURCES_ROOT . 'triangulos.zip'; // Log in as contest director $r['auth_token'] = $this->login($problemData['author']); // Call API $response = ProblemController::apiUpdate($r); // Verify data in DB $problem_mask = new Problems(); $problem_mask->setTitle($r['title']); $problems = ProblemsDAO::search($problem_mask); // Check that we only retreived 1 element $this->assertEquals(1, count($problems)); // Validate rsponse $this->assertEquals('ok', $response['status']); $this->assertEquals(true, $response['rejudged']); $this->assertEquals('cases/1.in', $response['uploaded_files'][0]); // Verify problem contents were copied $targetpath = PROBLEMS_PATH . DIRECTORY_SEPARATOR . $r['problem_alias'] . DIRECTORY_SEPARATOR; $this->assertFileExists($targetpath . 'cases'); $this->assertFileExists($targetpath . 'statements/es.html'); $this->assertFileNotExists($targetpath . 'examples/sample.in'); // Check update in statements $statement = file_get_contents($targetpath . 'statements' . DIRECTORY_SEPARATOR . 'es.html'); $this->assertContains('perímetro', $statement); $this->assertEquals(12345, $problems[0]->stack_limit); // Call API again to add an example, should not trigger rejudge. $_FILES['problem_contents']['tmp_name'] = OMEGAUP_RESOURCES_ROOT . 'triangulos-examples.zip'; $response = ProblemController::apiUpdate($r); $this->assertEquals('ok', $response['status']); $this->assertEquals(false, $response['rejudged']); $this->assertFileExists($targetpath . 'examples/sample.in'); }
/** * Contestant submits runs and admin is able to get them */ public function testGetRunsForContest() { // Get a problem $problemData = ProblemsFactory::createProblem(); // Get a contest $contestData = ContestsFactory::createContest(); // Add the problem to the contest ContestsFactory::addProblemToContest($problemData, $contestData); // Create our contestant $contestant = UserFactory::createUser(); // Create a run $runData = RunsFactory::createRun($problemData, $contestData, $contestant); // Grade the run RunsFactory::gradeRun($runData); // Create request $r = new Request(); $r['contest_alias'] = $contestData['request']['alias']; $r['auth_token'] = $this->login($contestData['director']); // Call API $response = ContestController::apiRuns($r); // Assert $this->assertEquals(1, count($response['runs'])); $this->assertEquals($runData['response']['guid'], $response['runs'][0]['guid']); $this->assertEquals($contestant->username, $response['runs'][0]['username']); $this->assertEquals('J1', $response['runs'][0]['judged_by']); }
public function testCoderOfTheMonthCalc() { $user = UserFactory::createUser(); $contest = ContestsFactory::createContest(); $problem = ProblemsFactory::createProblem(); ContestsFactory::addProblemToContest($problem, $contest); ContestsFactory::addUser($contest, $user); // Creating 10 AC runs for our user in the last month $n = 10; $lastMonth = intval(date('m')) - 1; $runCreationDate = null; if ($lastMonth == 0) { $runCreationDate = date(intval(date('Y') - 1) . '-12-01'); } else { $runCreationDate = date('Y-' . $lastMonth . '-01'); } for ($i = 0; $i < $n; $i++) { $runData = RunsFactory::createRun($problem, $contest, $user); RunsFactory::gradeRun($runData); // Force the run to be in last month $run = RunsDAO::getByAlias($runData['response']['guid']); $run->setTime($runCreationDate); RunsDAO::save($run); } $response = UserController::apiCoderOfTheMonth(new Request()); $this->assertEquals($user->getUsername(), $response['userinfo']['username']); }
public function testSimpleRegistrationActions() { self::log("Started"); //create a contest and its admin $contestData = ContestsFactory::createContest(null, 1); $contestAdmin = UserFactory::createUser(); ContestsFactory::addAdminUser($contestData, $contestAdmin); //make it "registrable" self::log("Udate contest to make it registrable"); $r1 = new Request(); $r1["contest_alias"] = $contestData["request"]["alias"]; $r1["contestant_must_register"] = true; $r1["auth_token"] = $this->login($contestAdmin); ContestController::apiUpdate($r1); //some user asks for contest $contestant = UserFactory::createUser(); $r2 = new Request(); $r2["contest_alias"] = $contestData["request"]["alias"]; $r2["auth_token"] = $this->login($contestant); try { $response = ContestController::apiDetails($r2); $this->AssertFalse(true, "User gained access to contest even though its registration needed."); } catch (ForbiddenAccessException $fae) { // Expected. Continue. } self::log("user registers, into contest"); ContestController::apiRegisterForContest($r2); //admin lists registrations $r3 = new Request(); $r3["contest_alias"] = $contestData["request"]["alias"]; $r3["auth_token"] = $this->login($contestAdmin); $result = ContestController::apiRequests($r3); $this->assertEquals(sizeof($result["users"]), 1); self::log("amin rejects registration"); $r3["username"] = $contestant->username; $r3["resolution"] = false; ContestController::apiArbitrateRequest($r3); //ask for details again, this should fail again $r2 = new Request(); $r2["contest_alias"] = $contestData["request"]["alias"]; $r2["auth_token"] = $this->login($contestant); try { $response = ContestController::apiDetails($r2); $this->AssertFalse(true); } catch (ForbiddenAccessException $fae) { // Expected. Continue. } //admin admits user $r3["username"] = $contestant->username; $r3["resolution"] = true; ContestController::apiArbitrateRequest($r3); //user can now submit to contest $r2 = new Request(); $r2["contest_alias"] = $contestData["request"]["alias"]; $r2["auth_token"] = $this->login($contestant); // Explicitly join contest ContestController::apiOpen($r2); ContestController::apiDetails($r2); }
public function testArenaRoot() { // Create a contest $contestData = ContestsFactory::createContest(); // Open URL $this->open('/arena'); // Sanity check: Arena at leasts says 'Arena', it is not badly broken $this->assertElementContainsText('//*[@id="root"]/h1', 'Arena'); // Check that our latest contest is there $this->waitForElementPresent('//*[@id="current-contests"]/tr/td[1]/a'); $this->assertElementContainsText('//*[@id="current-contests"]/tr/td[1]/a', $contestData["request"]["title"]); }
/** * Creates a run * * @param type $problemData * @param type $contestData * @param Users $contestant * @return array */ public static function createRun($problemData, $contestData, $contestant) { // Our contestant has to open the contest before sending a run ContestsFactory::openContest($contestData, $contestant); // Then we need to open the problem ContestsFactory::openProblemInContest($contestData, $problemData, $contestant); $r = self::createRequestCommon($problemData, $contestData, $contestant); // Call API RunController::$grader = new GraderMock(); $response = RunController::apiCreate($r); // Clean up unset($_REQUEST); return array('request' => $r, 'contestant' => $contestant, 'response' => $response); }
/** * Tests that 2 contests with same name cannot be created * * @expectedException DuplicatedEntryInDatabaseException */ public function testCreate2ContestsWithSameAlias() { // Create a valid contest Request object $contestData = ContestsFactory::getRequest(); $r = $contestData['request']; $contestDirector = $contestData['director']; // Log in the user and set the auth token in the new request $r['auth_token'] = $this->login($contestDirector); // Call the API $response = ContestController::apiCreate($r); $this->assertEquals('ok', $response['status']); // Call the API for the 2nd time with same alias $response = ContestController::apiCreate($r); }
public function testContestActivityReport() { // Get a contest $contestData = ContestsFactory::createContest(); $user = UserFactory::createUser(); ContestsFactory::openContest($contestData, $user); ContestController::apiDetails(new Request(array('contest_alias' => $contestData['request']['alias'], 'auth_token' => $this->login($user)))); // Call API $response = ContestController::apiActivityReport(new Request(array('contest_alias' => $contestData['request']['alias'], 'auth_token' => $this->login($contestData['director'])))); // Check that we have entries in the log. $this->assertEquals(1, count($response['events'])); $this->assertEquals($user->username, $response['events'][0]['username']); $this->assertEquals(0, $response['events'][0]['ip']); $this->assertEquals('open', $response['events'][0]['event']['name']); }
/** * Test apiBestScore for submits inside a contest */ public function testBestScoreInsideContest() { // Create problem and contest $problemData = ProblemsFactory::createProblem(); $contestData = ContestsFactory::createContest(); ContestsFactory::addProblemToContest($problemData, $contestData); // Create contestant $contestant = UserFactory::createUser(); // Create 2 runs, 100 and 50. $runDataOutsideContest = RunsFactory::createRunToProblem($problemData, $contestant); $runDataInsideContest = RunsFactory::createRun($problemData, $contestData, $contestant); RunsFactory::gradeRun($runDataOutsideContest); RunsFactory::gradeRun($runDataInsideContest, 0.5, "PA"); // Call API $response = ProblemController::apiBestScore(new Request(array("auth_token" => $this->login($contestant), "problem_alias" => $problemData["request"]["alias"], "contest_alias" => $contestData["request"]["alias"]))); $this->assertEquals(50.0, $response["score"]); }
public function testCreateContest() { $contestData = ContestsFactory::getRequest(); // Login $director = $this->createUserAndLogin(); // Open contest create $this->open('/contestcreate.php'); // Use preioi template $this->click('//*[@id="preioi"]'); $this->type('name=title', $contestData['request']['title']); $this->type('name=alias', $contestData['request']['alias']); $this->type('name=description', $contestData['request']['description']); // Submit $this->click("//input[@value='Agendar concurso']"); sleep(1); $this->assertElementContainsText('//*[@id="content"]/div[2]/div', 'Tu concurso ha sido creado!'); }
public static function createContest($title = null, $public = 1, Users $contestDirector = null, $languages = null, $finish_time = null) { // Create a valid contest Request object $contestData = ContestsFactory::getRequest($title, 0, $contestDirector, $languages, $finish_time); $r = $contestData['request']; $contestDirector = $contestData['director']; // Log in the user and set the auth token in the new request $r['auth_token'] = OmegaupTestCase::login($contestDirector); // Call the API $response = ContestController::apiCreate($r); if ($public === 1) { self::forcePublic($contestData); $r['public'] = 1; } $contest = ContestsDAO::getByAlias($r['alias']); return array('director' => $contestData['director'], 'request' => $r, 'contest' => $contest); }
public static function createContest($title = null, $public = 1, Users $contestDirector = null, $languages = null) { // Create a valid contest Request object $contestData = ContestsFactory::getRequest($title, 0, $contestDirector, $languages); $r = $contestData["request"]; $contestDirector = $contestData["director"]; // Log in the user and set the auth token in the new request $r["auth_token"] = OmegaupTestCase::login($contestDirector); // Call the API $response = ContestController::apiCreate($r); if ($public === 1) { self::forcePublic($contestData); $r["public"] = 1; } $contest = ContestsDAO::getByAlias($r["alias"]); return array("director" => $contestData["director"], "request" => $r, "contest" => $contest); }
public function testProblemArenaAndSubmbit() { // Create a contestant $contestant = UserFactory::createUser(); // Create a problem $problemData = ProblemsFactory::createProblem(); // Get a contest $contestData = ContestsFactory::createContest(); // Add the problem to the contest ContestsFactory::addProblemToContest($problemData, $contestData); // Create a run $runData = RunsFactory::createRun($problemData, $contestData, $contestant); // Login $contestant = $this->createAdminUserAndLogin(); // Open ADMIN $this->open('/arena/admin'); // Wait for table to render with our run $this->waitForElementPresent('//*[@id="run_' . $runData['response']['guid'] . '"]/td[2]'); }
public function testRunTotals() { // Get a problem $problemData = ProblemsFactory::createProblem(); // Get a contest $contestData = ContestsFactory::createContest(); // Add the problem to the contest ContestsFactory::addProblemToContest($problemData, $contestData); // Create our contestant $contestant = UserFactory::createUser(); // Create a run $runData = RunsFactory::createRun($problemData, $contestData, $contestant); $runDataOld = RunsFactory::createRun($problemData, $contestData, $contestant); $run = RunsDAO::getByAlias($runDataOld['response']['guid']); $run->setTime(date('Y-m-d H:i:s', strtotime('-72 hours'))); RunsDAO::save($run); $response = RunController::apiCounts(new Request()); $this->assertGreaterThan(1, count($response)); }
/** * Basic test for getting the list of clarifications of a contest. * Create 4 clarifications in a contest with one user, then another 3 clarifications * with another user. * Get the list for the first user, will see only his 4 */ public function testListPublicClarificationsForContestant() { // Get a problem $problemData = ProblemsFactory::createProblem(); // Get a contest $contestData = ContestsFactory::createContest(); // Add the problem to the contest ContestsFactory::addProblemToContest($problemData, $contestData); // Create our contestant who will submit the clarification $contestant1 = UserFactory::createUser(); // Create 4 clarifications with this contestant $clarificationData1 = array(); $this->detourBroadcasterCalls($this->exactly(9)); for ($i = 0; $i < 4; $i++) { $clarificationData1[$i] = ClarificationsFactory::createClarification($problemData, $contestData, $contestant1); } // Answer clarification 0 and 2 ClarificationsFactory::answer($clarificationData1[0], $contestData); ClarificationsFactory::answer($clarificationData1[2], $contestData); // Create another contestant $contestant2 = UserFactory::createUser(); // Create 3 clarifications with this contestant $clarificationData2 = array(); for ($i = 0; $i < 3; $i++) { $clarificationData2[$i] = ClarificationsFactory::createClarification($problemData, $contestData, $contestant2); } // Prepare the request $r = new Request(); $r["contest_alias"] = $contestData["request"]["alias"]; // Log in with first user $r["auth_token"] = $this->login($contestant1); // Call API $response = ContestController::apiClarifications($r); // Check that we got all clarifications $this->assertEquals(count($clarificationData1), count($response["clarifications"])); // Check that the clarifications came in the order we expect // First we expect clarifications not answered $this->assertEquals($clarificationData1[3]["request"]["message"], $response["clarifications"][0]["message"]); $this->assertEquals($clarificationData1[1]["request"]["message"], $response["clarifications"][1]["message"]); // Then clarifications answered, newer first $this->assertEquals($clarificationData1[2]["request"]["message"], $response["clarifications"][2]["message"]); $this->assertEquals($clarificationData1[0]["request"]["message"], $response["clarifications"][3]["message"]); }
/** * Check stats are ok for WA, AC, PA and total counts * Also validates the max wait time guid */ public function testGetStats() { // Get a problem $problemData = ProblemsFactory::createProblem(); // Get a contest $contestData = ContestsFactory::createContest(); // Add the problem to the contest ContestsFactory::addProblemToContest($problemData, $contestData); // Create our contestant $contestant = UserFactory::createUser(); // Create some runs to be pending $pendingRunsCount = 5; $pendingRunsData = array(); for ($i = 0; $i < $pendingRunsCount; $i++) { $pendingRunsData[$i] = RunsFactory::createRun($problemData, $contestData, $contestant); } $ACRunsCount = 2; $ACRunsData = array(); for ($i = 0; $i < $ACRunsCount; $i++) { $ACRunsData[$i] = RunsFactory::createRun($problemData, $contestData, $contestant); // Grade the run RunsFactory::gradeRun($ACRunsData[$i]); } $WARunsCount = 1; $WARunsData = array(); for ($i = 0; $i < $WARunsCount; $i++) { $WARunsData[$i] = RunsFactory::createRun($problemData, $contestData, $contestant); // Grade the run with WA RunsFactory::gradeRun($WARunsData[$i], 0, "WA"); } // Create request $r = new Request(); $r["problem_alias"] = $problemData["request"]["alias"]; $r["auth_token"] = $this->login($problemData["author"]); // Call API $response = ProblemController::apiStats($r); // Check number of pending runs $this->assertEquals(count($pendingRunsData), count($response["pending_runs"])); $this->assertEquals(count($ACRunsData), $response["verdict_counts"]["AC"]); $this->assertEquals(count($WARunsData), $response["verdict_counts"]["WA"]); $this->assertEquals($pendingRunsCount + $ACRunsCount + $WARunsCount, $response["total_runs"]); }
/** * Tests remove admins */ public function testRemoveAdmin() { // Get a contest $contestData = ContestsFactory::createContest(); // Get users $user = UserFactory::createUser(); $user2 = UserFactory::createUser(); ContestsFactory::addAdminUser($contestData, $user); ContestsFactory::addAdminUser($contestData, $user2); // Prepare request for remove one admin $r = new Request(); $r["auth_token"] = $this->login($contestData["director"]); $r["usernameOrEmail"] = $user->getUsername(); $r["contest_alias"] = $contestData["request"]["alias"]; // Call api ContestController::apiRemoveAdmin($r); $contest = ContestsDAO::getByAlias($contestData['request']['alias']); $this->AssertFalse(Authorization::IsContestAdmin($user->getUserId(), $contest)); $this->AssertTrue(Authorization::IsContestAdmin($user2->getUserId(), $contest)); }
public function testProblemsSolved() { $user = UserFactory::createUser(); $contest = ContestsFactory::createContest(); $problemOne = ProblemsFactory::createProblem(); $problemTwo = ProblemsFactory::createProblem(); ContestsFactory::addProblemToContest($problemOne, $contest); ContestsFactory::addProblemToContest($problemTwo, $contest); ContestsFactory::addUser($contest, $user); $runs = array(); $runs[0] = RunsFactory::createRun($problemOne, $contest, $user); $runs[1] = RunsFactory::createRun($problemTwo, $contest, $user); $runs[2] = RunsFactory::createRun($problemOne, $contest, $user); RunsFactory::gradeRun($runs[0]); RunsFactory::gradeRun($runs[1]); RunsFactory::gradeRun($runs[2]); $r = new Request(array("auth_token" => self::login($user))); $response = UserController::apiProblemsSolved($r); $this->assertEquals(2, count($response["problems"])); }
/** * Creates a clarification in a problem inside a contest * * @param type $problemData * @param type $contestData * @param type $contestant */ public static function createClarification($problemData, $contestData, $contestant) { // Our contestant has to open the contest before sending a clarification ContestsFactory::openContest($contestData, $contestant); // Then we need to open the problem ContestsFactory::openProblemInContest($contestData, $problemData, $contestant); // Create the request for our api $r = new Request(); $r["message"] = Utils::CreateRandomString(); $r["contest_alias"] = $contestData["request"]["alias"]; $r["problem_alias"] = $problemData["request"]["alias"]; $r["public"] = '0'; // Log in our user and set the auth_token properly $r["auth_token"] = OmegaupTestCase::login($contestant); // Call the API $response = ClarificationController::apiCreate($r); // Clean up stuff unset($_REQUEST); return array("request" => $r, "response" => $response); }
/** * Update from private to public with problems added * */ public function testUpdatePrivateContestToPublicWithProblems() { // Get a contest $contestData = ContestsFactory::createContest(null, 0); // Get a problem $problemData = ProblemsFactory::createProblem(); // Add the problem to the contest ContestsFactory::addProblemToContest($problemData, $contestData); // Prepare request $r = new Request(); $r["contest_alias"] = $contestData["request"]["alias"]; // Log in with contest director $r["auth_token"] = $this->login($contestData["director"]); // Update public $r["public"] = 1; // Call API $response = ContestController::apiUpdate($r); $contestData["request"]["public"] = $r["public"]; $this->assertContest($contestData["request"]); }
/** * Test getting list of contests where the user is the admin */ public function testAdminList() { // Our director $director = UserFactory::createUser(); // Get two contests with another director, add $director to their admin list $contestAdminData[0] = ContestsFactory::createContest(); ContestsFactory::addAdminUser($contestAdminData[0], $director); $contestAdminData[1] = ContestsFactory::createContest(); ContestsFactory::addAdminUser($contestAdminData[1], $director); $contestDirectorData[0] = ContestsFactory::createContest(null, 1, $director); $contestDirectorData[1] = ContestsFactory::createContest(null, 1, $director); // Call api $r = new Request(array("auth_token" => self::login($director))); $response = UserController::apiContests($r); // Contests should come ordered by contest id desc $this->assertEquals(count($contestDirectorData) + count($contestAdminData), count($response["contests"])); $this->assertEquals($contestDirectorData[1]["request"]["alias"], $response["contests"][0]["alias"]); $this->assertEquals($contestDirectorData[0]["request"]["alias"], $response["contests"][1]["alias"]); $this->assertEquals($contestAdminData[1]["request"]["alias"], $response["contests"][2]["alias"]); $this->assertEquals($contestAdminData[0]["request"]["alias"], $response["contests"][3]["alias"]); }
/** * Basic test of viewing run details * */ public function testShowRunDetailsValid() { // Get a problem $problemData = ProblemsFactory::createProblem(); // Get a contest $contestData = ContestsFactory::createContest(); // Add the problem to the contest ContestsFactory::addProblemToContest($problemData, $contestData); // Create our contestant $contestant = UserFactory::createUser(); // Create a run $runData = RunsFactory::createRun($problemData, $contestData, $contestant); // Prepare request $r = new Request(); $r["auth_token"] = $this->login($contestant); $r["run_alias"] = $runData["response"]["guid"]; // Call API $response = RunController::apiStatus($r); $this->assertEquals($r["run_alias"], $response["guid"]); $this->assertEquals("JE", $response["verdict"]); $this->assertEquals("new", $response["status"]); }
/** * Basic test of viewing run details * */ public function testShowRunDetailsValid() { // Get a problem $problemData = ProblemsFactory::createProblem(); // Get a contest $contestData = ContestsFactory::createContest(); // Add the problem to the contest ContestsFactory::addProblemToContest($problemData, $contestData); // Create our contestant $contestant = UserFactory::createUser(); // Create a run $runData = RunsFactory::createRun($problemData, $contestData, $contestant); // Prepare request $r = new Request(); $r['auth_token'] = $this->login($contestant); $r['run_alias'] = $runData['response']['guid']; // Call API $response = RunController::apiStatus($r); $this->assertEquals($r['run_alias'], $response['guid']); $this->assertEquals('JE', $response['verdict']); $this->assertEquals('new', $response['status']); }
/** * Basic test for answer * */ public function testUpdateAnswer() { // Get a problem $problemData = ProblemsFactory::createProblem(); // Get a contest $contestData = ContestsFactory::createContest(); // Add the problem to the contest ContestsFactory::addProblemToContest($problemData, $contestData); // Create our contestant who will submit the clarification $contestant = UserFactory::createUser(); // Create clarification $this->detourBroadcasterCalls($this->exactly(2)); $clarificationData = ClarificationsFactory::createClarification($problemData, $contestData, $contestant); // Update answer $newAnswer = 'new answer'; $response = ClarificationsFactory::answer($clarificationData, $contestData, $newAnswer); // Get clarification from DB $clarification = ClarificationsDAO::getByPK($clarificationData['response']['clarification_id']); // Validate that clarification stays the same $this->assertEquals($clarificationData['request']['message'], $clarification->getMessage()); $this->assertEquals($clarificationData['request']['public'], $clarification->getPublic()); // Validate our update $this->assertEquals($newAnswer, $clarification->getAnswer()); }