function testForceChangeUpdatesVersion()
 {
     $obj = new VersionedTest_DataObject();
     $obj->Name = "test";
     $obj->write();
     $oldVersion = $obj->Version;
     $obj->forceChange();
     $obj->write();
     $this->assertTrue($obj->Version > $oldVersion, "A object Version is increased when just calling forceChange() without any other changes");
 }
 public function testArchiveRelatedDataWithoutVersioned()
 {
     SS_Datetime::set_mock_now('2009-01-01 00:00:00');
     $relatedData = new VersionedTest_RelatedWithoutVersion();
     $relatedData->Name = 'Related Data';
     $relatedDataId = $relatedData->write();
     $testData = new VersionedTest_DataObject();
     $testData->Title = 'Test';
     $testData->Content = 'Before Content';
     $testData->Related()->add($relatedData);
     $id = $testData->write();
     SS_Datetime::set_mock_now('2010-01-01 00:00:00');
     $testData->Content = 'After Content';
     $testData->write();
     Versioned::reading_archived_date('2009-01-01 19:00:00');
     $fetchedData = VersionedTest_DataObject::get()->byId($id);
     $this->assertEquals('Before Content', $fetchedData->Content, 'We see the correct content of the older version');
     $relatedData = VersionedTest_RelatedWithoutVersion::get()->byId($relatedDataId);
     $this->assertEquals(1, $relatedData->Related()->count(), 'We have a relation, with no version table, querying it still works');
 }
Example #3
0
	/**
	 * This tests for the situation described in the ticket #5596. 
	 * Writing new Page to live first creates a row in VersionedTest_DataObject table (to get the new ID), then "changes
	 * it's mind" in Versioned and writes VersionedTest_DataObject_Live. It does not remove the VersionedTest_DataObject record though.
	 */ 
	function testWritingNewToLive() {
		$origStage = Versioned::current_stage();
		
		Versioned::reading_stage("Live");
		$page = new VersionedTest_DataObject();
		$page->Title = "testWritingNewToLive";
		$page->URLSegment = "testWritingNewToLive";
		$page->write();
		
		$live = Versioned::get_by_stage('VersionedTest_DataObject', 'Live', "\"VersionedTest_DataObject_Live\".\"ID\"='$page->ID'");
		$this->assertEquals(1, $live->count());
		$this->assertEquals($live->First()->Title, 'testWritingNewToLive');
		
		$stage = Versioned::get_by_stage('VersionedTest_DataObject', 'Stage', "\"VersionedTest_DataObject\".\"ID\"='$page->ID'");
		$this->assertEquals(0, $stage->count());
		
		Versioned::reading_stage($origStage);
	}
Example #4
0
 public function testGetVersionWhenClassnameChanged()
 {
     $obj = new VersionedTest_DataObject();
     $obj->Name = "test";
     $obj->write();
     $obj->Name = "test2";
     $obj->ClassName = "VersionedTest_Subclass";
     $obj->write();
     $subclassVersion = $obj->Version;
     $obj->Name = "test3";
     $obj->ClassName = "VersionedTest_DataObject";
     $obj->write();
     // We should be able to pass the subclass and still get the correct class back
     $obj2 = Versioned::get_version("VersionedTest_Subclass", $obj->ID, $subclassVersion);
     $this->assertInstanceOf("VersionedTest_Subclass", $obj2);
     $this->assertEquals("test2", $obj2->Name);
     $obj3 = Versioned::get_latest_version("VersionedTest_Subclass", $obj->ID);
     $this->assertEquals("test3", $obj3->Name);
     $this->assertInstanceOf("VersionedTest_DataObject", $obj3);
 }
 public function testStageStates()
 {
     // newly created page
     $createdPage = new VersionedTest_DataObject();
     $createdPage->write();
     $this->assertTrue($createdPage->isOnDraft());
     $this->assertFalse($createdPage->isPublished());
     $this->assertTrue($createdPage->isOnDraftOnly());
     $this->assertTrue($createdPage->isModifiedOnDraft());
     // published page
     $publishedPage = new VersionedTest_DataObject();
     $publishedPage->write();
     $publishedPage->copyVersionToStage('Stage', 'Live');
     $this->assertTrue($publishedPage->isOnDraft());
     $this->assertTrue($publishedPage->isPublished());
     $this->assertFalse($publishedPage->isOnDraftOnly());
     $this->assertFalse($publishedPage->isOnLiveOnly());
     $this->assertFalse($publishedPage->isModifiedOnDraft());
     // published page, deleted from stage
     $deletedFromDraftPage = new VersionedTest_DataObject();
     $deletedFromDraftPage->write();
     $deletedFromDraftPage->copyVersionToStage('Stage', 'Live');
     $deletedFromDraftPage->deleteFromStage('Stage');
     $this->assertFalse($deletedFromDraftPage->isArchived());
     $this->assertFalse($deletedFromDraftPage->isOnDraft());
     $this->assertTrue($deletedFromDraftPage->isPublished());
     $this->assertFalse($deletedFromDraftPage->isOnDraftOnly());
     $this->assertTrue($deletedFromDraftPage->isOnLiveOnly());
     $this->assertFalse($deletedFromDraftPage->isModifiedOnDraft());
     // published page, deleted from live
     $deletedFromLivePage = new VersionedTest_DataObject();
     $deletedFromLivePage->write();
     $deletedFromLivePage->copyVersionToStage('Stage', 'Live');
     $deletedFromLivePage->deleteFromStage('Live');
     $this->assertFalse($deletedFromLivePage->isArchived());
     $this->assertTrue($deletedFromLivePage->isOnDraft());
     $this->assertFalse($deletedFromLivePage->isPublished());
     $this->assertTrue($deletedFromLivePage->isOnDraftOnly());
     $this->assertFalse($deletedFromLivePage->isOnLiveOnly());
     $this->assertTrue($deletedFromLivePage->isModifiedOnDraft());
     // published page, deleted from both stages
     $deletedFromAllStagesPage = new VersionedTest_DataObject();
     $deletedFromAllStagesPage->write();
     $deletedFromAllStagesPage->copyVersionToStage('Stage', 'Live');
     $deletedFromAllStagesPage->doArchive();
     $this->assertTrue($deletedFromAllStagesPage->isArchived());
     $this->assertFalse($deletedFromAllStagesPage->isOnDraft());
     $this->assertFalse($deletedFromAllStagesPage->isPublished());
     $this->assertFalse($deletedFromAllStagesPage->isOnDraftOnly());
     $this->assertFalse($deletedFromAllStagesPage->isOnLiveOnly());
     $this->assertFalse($deletedFromAllStagesPage->isModifiedOnDraft());
     // published page, modified
     $modifiedOnDraftPage = new VersionedTest_DataObject();
     $modifiedOnDraftPage->write();
     $modifiedOnDraftPage->copyVersionToStage('Stage', 'Live');
     $modifiedOnDraftPage->Content = 'modified';
     $modifiedOnDraftPage->write();
     $this->assertFalse($modifiedOnDraftPage->isArchived());
     $this->assertTrue($modifiedOnDraftPage->isOnDraft());
     $this->assertTrue($modifiedOnDraftPage->isPublished());
     $this->assertFalse($modifiedOnDraftPage->isOnDraftOnly());
     $this->assertFalse($modifiedOnDraftPage->isOnLiveOnly());
     $this->assertTrue($modifiedOnDraftPage->isModifiedOnDraft());
 }