public function testGetProperties_ConstructsCorrectTypes() { $e = new MongoTestEnvironment(); $project = $e->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $entry = new LexEntryModel($project); $this->assertIsA($entry->senses, 'Api\\Model\\Mapper\\ArrayOf'); $this->assertIsA($entry->customFields, 'Api\\Model\\Mapper\\MapOf'); $this->assertIsA($entry->authorInfo, 'Api\\Model\\Languageforge\\Lexicon\\AuthorInfo'); $this->assertIsA($entry->lexeme, 'Api\\Model\\Languageforge\\Lexicon\\MultiText'); $this->assertIsA($entry->pronunciation, 'Api\\Model\\Languageforge\\Lexicon\\MultiText'); $this->assertIsA($entry->cvPattern, 'Api\\Model\\Languageforge\\Lexicon\\MultiText'); $this->assertIsA($entry->citationForm, 'Api\\Model\\Languageforge\\Lexicon\\MultiText'); $this->assertIsA($entry->etymology, 'Api\\Model\\Languageforge\\Lexicon\\MultiText'); $this->assertIsA($entry->etymologyGloss, 'Api\\Model\\Languageforge\\Lexicon\\MultiText'); $this->assertIsA($entry->etymologyComment, 'Api\\Model\\Languageforge\\Lexicon\\MultiText'); $this->assertIsA($entry->etymologySource, 'Api\\Model\\Languageforge\\Lexicon\\MultiText'); $this->assertIsA($entry->note, 'Api\\Model\\Languageforge\\Lexicon\\MultiText'); $this->assertIsA($entry->literalMeaning, 'Api\\Model\\Languageforge\\Lexicon\\MultiText'); $this->assertIsA($entry->entryBibliography, 'Api\\Model\\Languageforge\\Lexicon\\MultiText'); $this->assertIsA($entry->entryRestrictions, 'Api\\Model\\Languageforge\\Lexicon\\MultiText'); $this->assertIsA($entry->summaryDefinition, 'Api\\Model\\Languageforge\\Lexicon\\MultiText'); // Removed import residue. Its no longer a field we import CP 2014-10 // $this->assertIsA($entry->entryImportResidue, 'models\languageforge\lexicon\MultiText'); $this->assertIsA($entry->tone, 'Api\\Model\\Languageforge\\Lexicon\\MultiText'); $this->assertIsA($entry->environments, 'Api\\Model\\Languageforge\\Lexicon\\LexiconMultiValueField'); $this->assertIsA($entry->location, 'Api\\Model\\Languageforge\\Lexicon\\LexiconField'); }
public function testGetProperties_ConstructsCorrectTypes() { $environ = new MongoTestEnvironment(); $project = $environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $entry = new LexEntryModel($project); $this->assertInstanceOf(ArrayOf::class, $entry->senses); $this->assertInstanceOf(MapOf::class, $entry->customFields); $this->assertInstanceOf(LexAuthorInfo::class, $entry->authorInfo); $this->assertInstanceOf(LexMultiText::class, $entry->lexeme); $this->assertInstanceOf(LexMultiText::class, $entry->pronunciation); $this->assertInstanceOf(LexMultiText::class, $entry->cvPattern); $this->assertInstanceOf(LexMultiText::class, $entry->citationForm); $this->assertInstanceOf(LexMultiText::class, $entry->etymology); $this->assertInstanceOf(LexMultiText::class, $entry->etymologyGloss); $this->assertInstanceOf(LexMultiText::class, $entry->etymologyComment); $this->assertInstanceOf(LexMultiText::class, $entry->etymologySource); $this->assertInstanceOf(LexMultiText::class, $entry->note); $this->assertInstanceOf(LexMultiText::class, $entry->literalMeaning); $this->assertInstanceOf(LexMultiText::class, $entry->entryBibliography); $this->assertInstanceOf(LexMultiText::class, $entry->entryRestrictions); $this->assertInstanceOf(LexMultiText::class, $entry->summaryDefinition); // Removed import residue. Its no longer a field we import CP 2014-10 // $this->assertInstanceOf(LexMultiText::class, $entry->entryImportResidue); $this->assertInstanceOf(LexMultiText::class, $entry->tone); $this->assertInstanceOf(LexMultiValue::class, $entry->environments); $this->assertInstanceOf(LexValue::class, $entry->location); }
public function testEncode_userProjectHasNoUserProfileProperties_noProjectSettings() { $environ = new MongoTestEnvironment(); $environ->clean(); $userId = $environ->createUser("User", "Name", "*****@*****.**"); $user = new UserProfileModel($userId); $user->role = SiteRoles::USER; $project = $environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $projectId = $project->id->asString(); $project->addUser($userId, ProjectRoles::CONTRIBUTOR); $user->addProject($projectId); // user profile has data; but the encode method ignores it because the project has not enabled the 'city' property $projectUserProfile = new SfchecksUserProfile(); $projectUserProfile->city = 'myCity'; $user->projectUserProfiles[$projectId] = $projectUserProfile; $user->write(); $project->write(); $dto = UserProfileDto::encode($userId, $environ->website); $this->assertInternalType('array', $dto['userProfile']); $this->assertEquals($userId, $dto['userProfile']['id']); $this->assertEquals('Name', $dto['userProfile']['name']); $this->assertEquals(SiteRoles::USER, $dto['userProfile']['role']); $this->assertArrayHasKey('avatar_shape', $dto['userProfile']); $this->assertArrayHasKey('avatar_color', $dto['userProfile']); $this->assertFalse(isset($dto['userProfile']['projects'])); $this->assertInternalType('array', $dto['projectsSettings']); $this->assertEquals(0, count($dto['projectsSettings'])); }
public function testAnswerCRUD_Works() { $e = new MongoTestEnvironment(); $e->clean(); $textRef = MongoTestEnvironment::mockId(); $project = $e->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); // Create Question $question = new QuestionModel($project); $question->title = "Some Question"; $question->textRef->id = $textRef; $questionId = $question->write(); // List $question->read($questionId); $count = count($question->answers); $this->assertEqual(0, $count); // Create $answer = new AnswerModel(); $answer->content = 'Some answer'; $id = $question->writeAnswer($answer); $comment = new CommentModel(); $comment->content = 'Some comment'; $commentId = QuestionModel::writeComment($project->databaseName(), $questionId, $id, $comment); $this->assertNotNull($id); $this->assertIsA($id, 'string'); $this->assertEqual(24, strlen($id)); $this->assertEqual($id, $answer->id->asString()); // Read back $otherQuestion = new QuestionModel($project, $questionId); $otherAnswer = $otherQuestion->answers[$id]; $this->assertEqual($id, $otherAnswer->id->asString()); $this->assertEqual('Some answer', $otherAnswer->content); $this->assertEqual(1, count($otherAnswer->comments)); // Update $otherAnswer->content = 'Other answer'; // Note: Updates to the AnswerModel should not clobber child nodes such as comments. Hence this test. // See https://github.com/sillsdev/sfwebchecks/issues/39 unset($otherAnswer->comments[$commentId]); $otherQuestion->read($otherQuestion->id->asString()); $otherId = $otherQuestion->writeAnswer($otherAnswer); $this->assertEqual($id, $otherId); // Read back $otherQuestion = new QuestionModel($project, $questionId); $otherAnswer = $otherQuestion->answers[$id]; $this->assertEqual($id, $otherAnswer->id->asString()); $this->assertEqual('Other answer', $otherAnswer->content); $this->assertEqual(1, count($otherAnswer->comments)); // List $this->assertEqual(1, count($otherQuestion->answers)); // Delete QuestionModel::removeAnswer($project->databaseName(), $questionId, $id); // List $otherQuestion->read($questionId); $this->assertEqual(0, count($otherQuestion->answers)); }
public function testUserCanAccessMethod_projectPageDto_NotAMember_false() { $userId = $this->environ->createUser('user', 'user', '*****@*****.**', SystemRoles::USER); $project = $this->environ->createProject('projectForTest', 'projTestCode'); $project->appName = 'sfchecks'; $project->write(); $projectId = $project->id->asString(); $project = ProjectModel::getById($projectId); $rh = new RightsHelper($userId, $project, $this->environ->website); $result = $rh->userCanAccessMethod('project_pageDto', array()); $this->assertFalse($result); }
public function testAnswerCRUD_Works() { $environ = new MongoTestEnvironment(); $environ->clean(); $textRef = MongoTestEnvironment::mockId(); $project = $environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); // Create Question $question = new QuestionModel($project); $question->title = "Some Question"; $question->textRef->id = $textRef; $questionId = $question->write(); // Create Answer $answer = new AnswerModel(); $answer->content = 'Some answer'; $answerId = $question->writeAnswer($answer); // List $question->read($questionId); $count = count($question->answers[$answerId]->comments); $this->assertEquals(0, $count); // Create $comment = new CommentModel(); $comment->content = 'Some comment'; $id = QuestionModel::writeComment($project->databaseName(), $questionId, $answerId, $comment); $this->assertNotNull($id); $this->assertInternalType('string', $id); $this->assertEquals(24, strlen($id)); $this->assertEquals($comment->id->asString(), $id); // Read back $otherQuestion = new QuestionModel($project, $questionId); $otherComment = $otherQuestion->answers[$answerId]->comments[$id]; $this->assertEquals($id, $otherComment->id->asString()); $this->assertEquals('Some comment', $otherComment->content); // Update $otherComment->content = 'Other comment'; $otherId = $question->writeComment($project->databaseName(), $questionId, $answerId, $otherComment); $this->assertEquals($id, $otherId); // Read back $otherQuestion = new QuestionModel($project, $questionId); $otherComment = $otherQuestion->answers[$answerId]->comments[$id]; $this->assertEquals($id, $otherComment->id->asString()); $this->assertEquals('Other comment', $otherComment->content); // List $count = count($otherQuestion->answers[$answerId]->comments); $this->assertEquals(1, $count); // Delete QuestionModel::removeComment($project->databaseName(), $questionId, $answerId, $id); // List $otherQuestion->read($questionId); $count = count($otherQuestion->answers[$answerId]->comments); $this->assertEquals(0, $count); }
public function create() { $environ = new MongoTestEnvironment(); $environ->clean(); $this->website = $environ->website; $this->project = $environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $this->project->appName = 'sfchecks'; $this->project->write(); $this->question = new QuestionModel($this->project); $this->question->write(); $this->userId = $environ->createUser('test_user', 'Test User', '*****@*****.**'); $this->projectId = $this->project->id->asString(); $this->questionId = $this->question->id->asString(); }
public function testTextReference_NullRefValidRef_AllowsNullRef() { $e = new MongoTestEnvironment(); $project = $e->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $mockTextRef = (string) new \MongoId(); // Test create with null textRef $question = new QuestionModel($project); $id = $question->write(); $otherQuestion = new QuestionModel($project, $id); $this->assertEqual('', $otherQuestion->textRef->id); // Test update with textRef $question->textRef->id = $mockTextRef; $question->write(); $otherQuestion = new QuestionModel($project, $id); $this->assertEqual($mockTextRef, $otherQuestion->textRef->id); }
public function testUpdateThenRemove_NewProject_CreatesThenRemovesProjectDatabase() { $environ = new MongoTestEnvironment(); $environ->clean(); $project = $environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $databaseName = $project->databaseName(); $project->remove(); $this->assertEquals(0, MongoStore::countCollections($databaseName)); $text = new TextModel($project); $text->title = 'Some Title'; $text->write(); $this->assertTrue(MongoStore::hasDB($databaseName)); $this->assertEquals(1, MongoStore::countCollections($databaseName)); $project->remove(); $this->assertEquals(0, MongoStore::countCollections($databaseName)); }
public function testHasRight_Ok() { $userId = MongoTestEnvironment::mockId(); $project = new SfchecksProjectModel(); $project->addUser($userId, ProjectRoles::MANAGER); $result = $project->hasRight($userId, Domain::QUESTIONS + Operation::CREATE); $this->assertTrue($result); }
public function testCreateProject_newProject_projectOwnerSet() { $this->environ->clean(); $user1Id = $this->environ->createUser("user1name", "User1 Name", "*****@*****.**"); $user1 = new UserModel($user1Id); $projectID = ProjectCommands::createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE, 'sfchecks', $user1->id->asString(), $this->environ->website); $projectModel = new ProjectModel($projectID); $this->assertTrue($projectModel->ownerRef->asString() == $user1->id->asString()); }
public function testChangePassword_PasswordChanged() { // create user with a random password $e = new MongoTestEnvironment(); $userId = $e->createUser('test', 'test user', '*****@*****.**'); $passwordModel = new PasswordModel($userId); $someRandomPassword = '******'; // bcrypt for 'blahblah' $passwordModel->password = $someRandomPassword; $passwordModel->write(); // change the password to 12345 $password = '******'; $passwordModel->changePassword($password); $passwordModel->write(); // assert that the password was changed correctly $passwordModel2 = new PasswordModel($userId); $this->assertTrue($passwordModel2->verifyPassword($password)); }
public function testEncode_FullQuestionWithAnswersAndComments_DtoReturnsExpectedData() { $project = self::$environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $text = new TextModel($project); $text->title = "Text 1"; $usx = MongoTestEnvironment::usxSample(); $text->content = $usx; $textId = $text->write(); $user1Id = self::$environ->createUser("user1", "user1", "*****@*****.**"); $user2Id = self::$environ->createUser("user2", "user2", "*****@*****.**"); $user3Id = self::$environ->createUser("user3", "user3", "*****@*****.**"); // Workflow is first to create a question $question = new QuestionModel($project); $question->title = "the question"; $question->description = "question description"; $question->textRef->id = $textId; $questionId = $question->write(); // Then to add an answer to a question $answer = new AnswerModel(); $answer->content = "first answer"; $answer->score = 10; $answer->userRef->id = $user3Id; $answer->textHightlight = "text highlight"; $answerId = $question->writeAnswer($answer); // Followed by comments $comment1 = new CommentModel(); $comment1->content = "first comment"; $comment1->userRef->id = $user1Id; $comment1Id = QuestionModel::writeComment($project->databaseName(), $questionId, $answerId, $comment1); $comment2 = new CommentModel(); $comment2->content = "second comment"; $comment2->userRef->id = $user2Id; $comment2Id = QuestionModel::writeComment($project->databaseName(), $questionId, $answerId, $comment2); $dto = QuestionCommentDto::encode($project->id->asString(), $questionId, $user1Id); //var_dump($dto); $aid = $answerId; $cid1 = $comment1Id; $cid2 = $comment2Id; $this->assertEquals($project->id, $dto['project']['id']); //$this->assertEquals($text->content, $dto['text']['content']); $this->assertEquals($questionId, $dto['question']['id']); $this->assertEquals('the question', $dto['question']['title']); $this->assertEquals('question description', $dto['question']['description']); $this->assertEquals('first answer', $dto['question']['answers'][$aid]['content']); $this->assertEquals(10, $dto['question']['answers'][$aid]['score']); $this->assertEquals('user3.png', $dto['question']['answers'][$aid]['userRef']['avatar_ref']); $this->assertEquals('user3', $dto['question']['answers'][$aid]['userRef']['username']); $this->assertEquals('first comment', $dto['question']['answers'][$aid]['comments'][$cid1]['content']); $this->assertEquals('user1', $dto['question']['answers'][$aid]['comments'][$cid1]['userRef']['username']); $this->assertEquals('user1.png', $dto['question']['answers'][$aid]['comments'][$cid1]['userRef']['avatar_ref']); $this->assertEquals('second comment', $dto['question']['answers'][$aid]['comments'][$cid2]['content']); $this->assertEquals('user2', $dto['question']['answers'][$aid]['comments'][$cid2]['userRef']['username']); $this->assertEquals('user2.png', $dto['question']['answers'][$aid]['comments'][$cid2]['userRef']['avatar_ref']); }
public function testGetMetadata_Ok() { $usx = MongoTestEnvironment::usxSample(); $usxHelper = new UsxHelper($usx); $info = $usxHelper->getMetadata(); $this->assertEqual($info['bookCode'], 'JHN'); $this->assertEqual($info['startChapter'], 1); $this->assertEqual($info['endChapter'], 21); $this->assertEqual($info['startVerse'], 1); $this->assertEqual($info['endVerse'], 25); }
public function testEncode_ProjectWithUser_DtoCorrect() { $e = new MongoTestEnvironment(); $e->clean(); $userId = $e->createUser("User", "Name", "*****@*****.**"); $user = new UserModel($userId); $user->role = SystemRoles::USER; $project = $e->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $projectId = $project->id->asString(); $project->addUser($userId, ProjectRoles::CONTRIBUTOR); $user->addProject($projectId); $user->write(); $project->write(); $dto = ManageUsersDto::encode($projectId); $this->assertEqual($dto['userCount'], 1); $this->assertIsA($dto['users'], 'array'); $this->assertEqual($dto['users'][0]['id'], $userId); $this->assertEqual($dto['users'][0]['name'], 'Name'); $this->assertEqual($dto['users'][0]['role'], ProjectRoles::CONTRIBUTOR); }
public function testEncode_ProjectWith2Users1Unvalidated_DtoCorrect1User() { $e = new MongoTestEnvironment(); $e->clean(); $user1Id = $e->createUser("", "", ""); $user1 = new UserModel($user1Id); $user1->role = SystemRoles::USER; $user2Id = $e->createUser("User", "Name", "*****@*****.**"); $user2 = new UserModel($user2Id); $user2->role = SystemRoles::USER; $project = $e->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $projectId = $project->id->asString(); $project->addUser($user1Id, ProjectRoles::CONTRIBUTOR); $user1->addProject($projectId); $user1->write(); $project->addUser($user2Id, ProjectRoles::CONTRIBUTOR); $user2->addProject($projectId); $user2->write(); $project->write(); $text1 = new TextModel($project); $text1->title = "Some Title"; $text1->write(); $text2 = new TextModel($project); $text2->title = "Archived Title"; $text2->isArchived = true; $text2->write(); $dto = ProjectSettingsDto::encode($projectId, $user2Id); $this->assertEqual($dto['count'], 1); $this->assertIsA($dto['entries'], 'array'); $this->assertEqual($dto['entries'][0]['id'], $user2Id); $this->assertEqual($dto['entries'][0]['name'], 'Name'); $this->assertEqual($dto['entries'][0]['role'], ProjectRoles::CONTRIBUTOR); $this->assertEqual(count($dto['archivedTexts']), 1); $this->assertEqual($dto['archivedTexts'][0]['title'], 'Archived Title'); $this->assertTrue(count($dto['rights']) > 0, "No rights in dto"); $this->assertEqual($dto['bcs']['op'], 'settings'); $this->assertEqual($dto['bcs']['project'], array('id' => $projectId, 'crumb' => SF_TESTPROJECT)); $this->assertFalse(isset($dto['project']['users'])); $this->assertEqual($dto['project']['id'], $projectId); }
public function testEncode_ProjectWith2Users1Unvalidated_DtoCorrect1User() { $environ = new MongoTestEnvironment(); $environ->clean(); $user1Id = $environ->createUser('', '', ''); $user1 = new UserModel($user1Id); $user1->role = SystemRoles::USER; $user2Id = $environ->createUser('User', 'Name', '*****@*****.**'); $user2 = new UserModel($user2Id); $user2->role = SystemRoles::USER; $project = $environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $projectId = $project->id->asString(); $project->addUser($user1Id, ProjectRoles::CONTRIBUTOR); $user1->addProject($projectId); $user1->write(); $project->addUser($user2Id, ProjectRoles::CONTRIBUTOR); $user2->addProject($projectId); $user2->write(); $project->write(); $text1 = new TextModel($project); $text1->title = 'Some Title'; $text1->write(); $text2 = new TextModel($project); $text2->title = 'Archived Title'; $text2->isArchived = true; $text2->write(); $dto = ProjectSettingsDto::encode($projectId, $user2Id); $this->assertEquals(1, $dto['count']); $this->assertInternalType('array', $dto['entries']); $this->assertEquals($user2Id, $dto['entries'][0]['id']); $this->assertEquals('Name', $dto['entries'][0]['name']); $this->assertEquals(ProjectRoles::CONTRIBUTOR, $dto['entries'][0]['role']); $this->assertCount(1, $dto['archivedTexts']); $this->assertEquals('Archived Title', $dto['archivedTexts'][0]['title']); $this->assertTrue(count($dto['rights']) > 0, 'No rights in dto'); $this->assertEquals('settings', $dto['bcs']['op']); $this->assertEquals(array('id' => $projectId, 'crumb' => SF_TESTPROJECT), $dto['bcs']['project']); $this->assertFalse(isset($dto['project']['users'])); $this->assertEquals($projectId, $dto['project']['id']); }
public function testPublishTexts_2ArchivedTexts_1Published() { $e = new MongoTestEnvironment(); $e->clean(); $project = $e->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $text1 = new TextModel($project); $text1->title = "Some Title"; $text1->isArchived = true; $text1->write(); $text2 = new TextModel($project); $text2->title = "Another Title"; $text2->isArchived = true; $text2->write(); $this->assertEqual($text1->isArchived, true); $this->assertEqual($text2->isArchived, true); $count = TextCommands::publishTexts($project->id->asString(), array($text1->id->asString())); $text1->read($text1->id->asString()); $text2->read($text2->id->asString()); $this->assertEqual($count, 1); $this->assertEqual($text1->isArchived, false); $this->assertEqual($text2->isArchived, true); }
public function testUpdateProject_ReadOnlyProperties_PropertiesNotChanged() { $environ = new MongoTestEnvironment(); $environ->clean(); $userId = $environ->createUser('User', 'Name', '*****@*****.**'); $user = new UserModel($userId); $user->role = SystemRoles::USER; $hackerId = $environ->createUser('Hacker', 'Hacker', '*****@*****.**'); $hacker = new UserModel($hackerId); $hacker->role = SystemRoles::USER; $hacker->write(); $project = $environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $projectId = $project->id->asString(); $project->addUser($userId, ProjectRoles::MANAGER); $project->ownerRef = $user->id->asString(); $user->addProject($projectId); $user->write(); $project->write(); $hackedData = 'hacked'; $params = ProjectCommands::readProject($projectId); $params['projectName'] = 'new project name'; $params['id'] = $hackedData; $params['ownerRef'] = $hacker->id->asString(); $params['users'][$hacker->id->asString()]['role'] = ProjectRoles::MANAGER; $params['projectCode'] = $hackedData; $params['siteName'] = $hackedData; $params['appName'] = $hackedData; $params['userProperties']['userProfilePickLists']['city']['name'] = $hackedData; SfchecksProjectCommands::updateProject($projectId, $userId, $params); $updatedProject = ProjectCommands::readProject($projectId); $this->assertEquals('new project name', $updatedProject['projectName']); $this->assertNotEquals($hackedData, $updatedProject['id']); $this->assertNotEquals($hacker->id->asString(), $updatedProject['ownerRef']); $this->assertFalse(isset($updatedProject['users'][$hacker->id->asString()])); $this->assertNotEquals($hackedData, $updatedProject['projectCode']); $this->assertNotEquals($hackedData, $updatedProject['siteName']); $this->assertNotEquals($hackedData, $updatedProject['appName']); $this->assertNotEquals($hackedData, $updatedProject['userProperties']['userProfilePickLists']['city']['name']); }
public function testEncode_ProjectWithUser_DtoCorrect() { $e = new MongoTestEnvironment(); $e->clean(); $userId = $e->createUser("User", "Name", "*****@*****.**"); $user = new UserModel($userId); $project = $e->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE, 'sfchecks'); $project->ownerRef->id = $userId; $projectId = $project->id->asString(); $project->addUser($userId, ProjectRoles::CONTRIBUTOR); $user->addProject($projectId); $user->write(); $project->write(); $dto = ProjectManagementDto::encode($projectId); $this->assertTrue(count($dto['reports']) > 0); $foundUserEngagementReport = false; foreach ($dto['reports'] as $report) { if ($report['id'] == 'sfchecks_userEngagementReport') { $foundUserEngagementReport = true; } } $this->assertTrue($foundUserEngagementReport); }
function testCleanupFiles_4Files2Allowed_2Removed() { $environ = new MongoTestEnvironment(); $environ->clean(); $project = $environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $projectId = $project->write(); $text = new TextModel($project); $textId = $text->write(); $fakeId = new Id(); $fakeTextId = $fakeId->asString(); $folderPath = $project->getAssetsFolderPath(); FileUtilities::createAllFolders($folderPath); $allowedExtensions = array(".mp2", ".mp3"); // put a copy of the test files in the folderPath $fileName1 = 'TestAudio1.mp1'; $filePath1 = SfchecksUploadCommands::mediaFilePath($folderPath, $textId, $fileName1); copy(TestPath . 'common/TestAudio.mp3', $filePath1); $fileName2 = 'TestAudio2.mp2'; $filePath2 = SfchecksUploadCommands::mediaFilePath($folderPath, $textId, $fileName2); copy(TestPath . 'common/TestAudio.mp3', $filePath2); $fileName3 = 'TestAudio3.mp3'; $filePath3 = SfchecksUploadCommands::mediaFilePath($folderPath, $textId, $fileName3); copy(TestPath . 'common/TestAudio.mp3', $filePath3); $fileName4 = 'TestAudio4.mp3'; $filePath4 = SfchecksUploadCommands::mediaFilePath($folderPath, $fakeTextId, $fileName4); copy(TestPath . 'common/TestAudio.mp3', $filePath4); $this->assertTrue(file_exists($filePath1), 'File should exist before cleanup'); $this->assertTrue(file_exists($filePath2), 'File should exist before cleanup'); $this->assertTrue(file_exists($filePath3), 'File should exist before cleanup'); $this->assertTrue(file_exists($filePath4), 'File should exist before cleanup'); SfchecksUploadCommands::cleanupFiles($folderPath, $textId, $allowedExtensions); $this->assertTrue(file_exists($filePath1), 'File should exist after cleanup'); $this->assertFalse(file_exists($filePath2), 'File should not exist after cleanup'); $this->assertFalse(file_exists($filePath3), 'File should not exist after cleanup'); $this->assertTrue(file_exists($filePath4), 'File should exist after cleanup'); $environ->cleanupTestFiles($folderPath); }
public function testEncode_2Questions1Archived_DtoCorrect1ArchivedQuestion() { $e = new MongoTestEnvironment(); $e->clean(); $userId = $e->createUser("User", "Name", "*****@*****.**"); $user = new UserModel($userId); $user->role = SystemRoles::USER; $project = $e->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $projectId = $project->id->asString(); $project->addUser($userId, ProjectRoles::MANAGER); $user->addProject($projectId); $user->write(); $project->write(); $text = new TextModel($project); $text->title = "Text Title"; $textId = $text->write(); $question1 = new QuestionModel($project); $question1->title = "Some Title"; $question1->textRef->id = $textId; $question1->write(); $question2 = new QuestionModel($project); $question2->title = "Archived Title"; $question2->textRef->id = $textId; $question2->isArchived = true; $question2->write(); $dto = TextSettingsDto::encode($projectId, $textId, $userId); $this->assertIsA($dto['text'], 'array'); $this->assertEqual($dto['text']['id'], $textId); $this->assertEqual($dto['text']['title'], 'Text Title'); $this->assertIsA($dto['archivedQuestions'], 'array'); $this->assertEqual(count($dto['archivedQuestions']), 1); $this->assertEqual($dto['archivedQuestions'][0]['title'], 'Archived Title'); $this->assertTrue(count($dto['rights']) > 0, "No rights in dto"); $this->assertEqual($dto['bcs']['op'], 'settings'); $this->assertEqual($dto['bcs']['project'], array('id' => $projectId, 'crumb' => SF_TESTPROJECT)); }
public function testChangePassword_SystemAdminChangeOtherUser_Succeeds() { $this->environ->clean(); $adminModel = new Api\Model\UserModel(); $adminModel->username = '******'; $adminModel->role = SystemRoles::SYSTEM_ADMIN; $adminId = $adminModel->write(); $userModel = new Api\Model\UserModel(); $userModel->username = '******'; $userModel->role = SystemRoles::NONE; $userId = $userModel->write(); $this->assertNotEqual($adminId, $userId); UserCommands::changePassword($userId, 'somepass', $adminId); $passwordModel = new PasswordModel($userId); $result = $passwordModel->verifyPassword('somepass'); $this->assertTrue($result, 'Could not verify changed password'); }
public function testCRUD_Works() { $e = new MongoTestEnvironment(); $e->clean(); $userId = $e->mockId(); $projectId = $e->mockId(); $questionId = $e->mockId(); $answerId = $e->mockId(); // Create $vote = new UserVoteModel($userId, $projectId, $questionId); $this->assertNotNull($vote); $this->assertTrue(empty($vote->id->id)); // Has vote should fail, answer is not yet present. $result = $vote->hasVote($answerId); $this->assertFalse($result); // Add vote, should then be present. $vote->addVote($answerId); $result = $vote->hasVote($answerId); $this->assertTrue($result); $id = $vote->write(); $this->assertNotNull($id); $this->assertIsA($id, 'string'); $this->assertEqual($id, $vote->id->asString()); // Read back $otherVote = new UserVoteModel($userId, $projectId, $questionId); $this->assertIsA($otherVote->id->id, 'string'); $this->assertEqual($id, $vote->id->asString()); $result = $otherVote->hasVote($answerId); $this->assertTrue($result); // Update $answer2Id = $e->mockId(); $otherVote->addVote($answer2Id); $otherVote->write(); // Read back $otherVote = new UserVoteModel($userId, $projectId, $questionId); $result = $otherVote->hasVote($answerId); $this->assertTrue($result); $result = $otherVote->hasVote($answer2Id); $this->assertTrue($result); // Remove vote, should no longer be present. $vote->removeVote($answerId); $result = $vote->hasVote($answerId); $this->assertFalse($result); // UserVoteModel::remove($projectModel->databaseName(), $id); }
public function testUserEngagementReport_simpleProjectWithQuestionsAndAnswers_AsExpected() { $e = new MongoTestEnvironment(); $e->clean(); $project = $e->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $text = new TextModel($project); $text->title = "Text 1"; $usx = MongoTestEnvironment::usxSample(); $text->content = $usx; $textId = $text->write(); $user1Id = $e->createUser("user1", "user1", "*****@*****.**"); $user2Id = $e->createUser("user2", "user2", "*****@*****.**"); $user3Id = $e->createUser("user3", "user3", "*****@*****.**"); ProjectCommands::updateUserRole($project->id->asString(), $user1Id); ProjectCommands::updateUserRole($project->id->asString(), $user2Id); ProjectCommands::updateUserRole($project->id->asString(), $user3Id); // Workflow is first to create a question $question = new QuestionModel($project); $question->title = "the question"; $question->description = "question description"; $question->textRef->id = $textId; $questionId = $question->write(); // Then to add an answer to a question $answer = new AnswerModel(); $answer->content = "first answer"; $answer->score = 10; $answer->userRef->id = $user3Id; $answer->textHightlight = "text highlight"; $answerId = $question->writeAnswer($answer); // Followed by comments $comment1 = new CommentModel(); $comment1->content = "first comment"; $comment1->userRef->id = $user1Id; $comment1Id = QuestionModel::writeComment($project->databaseName(), $questionId, $answerId, $comment1); $comment2 = new CommentModel(); $comment2->content = "second comment"; $comment2->userRef->id = $user2Id; $comment2Id = QuestionModel::writeComment($project->databaseName(), $questionId, $answerId, $comment2); $data = SfchecksReports::UserEngagementReport($project->id->asString()); $this->assertTrue($data['output']); }
public function testUpdateComment_ExistingComment_OriginalAuthorIsPreserved() { $e = new MongoTestEnvironment(); $e->clean(); $project = $e->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $text = new TextModel($project); $text->title = "Text 1"; $usx = MongoTestEnvironment::usxSample(); $text->content = $usx; $textId = $text->write(); $question = new QuestionModel($project); $question->textRef->id = $textId; $questionId = $question->write(); $user1Id = $e->createUser("user1", "user1", "user1"); $user2Id = $e->createUser("user2", "user2", "user2"); $answer = new AnswerModel(); $answer->content = "the answer"; $answer->userRef->id = $user2Id; $answerId = $question->writeAnswer($answer); $comment = new CommentModel(); $comment->userRef->id = $user1Id; $comment->content = "the comment"; $commentId = $question->writeComment($project->databaseName(), $questionId, $answerId, $comment); $commentArray = array("id" => $commentId, "content" => "updated comment"); QuestionCommands::updateComment($project->id->asString(), $questionId, $answerId, $commentArray, $user2Id); $question->read($questionId); $newComment = $question->readComment($answerId, $commentId); $this->assertEqual($user1Id, $newComment->userRef->asString()); }
public function testTrim_zeroStartChapter() { // Start chapter of 0 means "from start of book" $usx = MongoTestEnvironment::usxSample(); $usxHelper = new UsxTrimHelper($usx, 0, 0, 3, 16); $result = $usxHelper->trimUsx(); $simple = new SimpleXMLElement($result); $this->assertTrue($this->hasChapter($simple, 1)); $this->assertTrue($this->hasChapter($simple, 2)); $this->assertTrue($this->hasChapter($simple, 3)); $this->assertFalse($this->hasChapter($simple, 4)); // John 1 has 51 verses; John 2 has 25 verses $this->assertTrue($this->hasVerse($simple, 1, 1)); $this->assertTrue($this->hasVerse($simple, 1, 51)); $this->assertTrue($this->hasVerse($simple, 2, 1)); $this->assertTrue($this->hasVerse($simple, 2, 25)); $this->assertTrue($this->hasVerse($simple, 3, 1)); $this->assertTrue($this->hasVerse($simple, 3, 16)); $this->assertFalse($this->hasVerse($simple, 3, 17)); $this->assertFalse($this->hasVerse($simple, 4, 1)); }
public function clean() { self::$englishProject = null; parent::clean(); }
public function testSendForgotPasswordVerification_PropertiesFromToBodyOk() { $e = new MongoTestEnvironment(); $e->clean(); $userId = $e->createUser('User', 'Name', '*****@*****.**'); $user = new UserModel($userId); $delivery = new MockCommunicateDelivery(); Communicate::sendForgotPasswordVerification($user, $e->website, $delivery); // What's in the delivery? $senderEmail = 'no-reply@' . $e->website->domain; $expectedFrom = array($senderEmail => $e->website->name); $expectedTo = array($user->email => $user->name); $this->assertEqual($expectedFrom, $delivery->from); $this->assertEqual($expectedTo, $delivery->to); $this->assertPattern('/' . $e->website->name . '/', $delivery->subject); $this->assertNoPattern('/<p>/', $delivery->content); $this->assertPattern('/Name/', $delivery->content); $this->assertPattern('/' . $user->resetPasswordKey . '/', $delivery->content); $this->assertPattern('/<p>/', $delivery->htmlContent); $this->assertPattern('/Name/', $delivery->htmlContent); $this->assertPattern('/' . $user->resetPasswordKey . '/', $delivery->htmlContent); }
public function testExportCommentsForText_QuestionArchived_NoneExported() { $project = self::$environ->createProject(SF_TESTPROJECT, SF_TESTPROJECTCODE); $text = new TextModel($project); $text->title = 'Text 1'; $usx = MongoTestEnvironment::usxSample(); $text->content = $usx; $textId = $text->write(); $user1Id = self::$environ->createUser('user1', 'user1', '*****@*****.**'); $user2Id = self::$environ->createUser('user2', 'user2', '*****@*****.**'); $user3Id = self::$environ->createUser('user3', 'user3', '*****@*****.**'); // Workflow is first to create a question $question = new QuestionModel($project); $question->title = 'the question'; $question->description = 'question description'; $question->textRef->id = $textId; $question->isArchived = true; $question->write(); // Then to add an answer to a question $answer = new AnswerModel(); $answer->content = 'first answer'; $answer->score = 10; $answer->userRef->id = $user1Id; $answer->tags->exchangeArray(array('export', 'to review')); $answer->isToBeExported = true; $question->writeAnswer($answer); // Then to add an answer to a question $answer = new AnswerModel(); $answer->content = 'second answer - very long'; $answer->score = 2; $answer->userRef->id = $user2Id; $answer->tags->exchangeArray(array('to review')); $answer->isToBeExported = false; $question->writeAnswer($answer); // Then to add an answer to a question $answer = new AnswerModel(); $answer->content = 'third answer - very very very very long'; $answer->userRef->id = $user3Id; $answer->tags->exchangeArray(array('export')); $answer->isToBeExported = true; $question->writeAnswer($answer); $params = array('textId' => $textId, 'exportComments' => true, 'exportFlagged' => true, 'tags' => array()); $download = ParatextExport::exportCommentsForText($project->id->asString(), $textId, $params); // echo '<pre>' . print_r($download) . '</pre>'; $this->assertNotRegExp('/<Contents>third answer - very very very very long \\(by user3/', $download['xml']); $this->assertNotRegExp('/<Contents>second answer/', $download['xml']); $this->assertNotRegExp('/<Contents>first answer/', $download['xml']); }