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']);
}
