ElasticSearchPageTest::testCMSFields() - Code Metrics - gordonbanderson/silverstripe-elastica - Measure and Improve Code Quality continuously with Scrutinizer

ElasticSearchPageTest::testCMSFields() B
last analyzed 2016-01-04 04:20 UTC

↳ Parent: ElasticSearchPageTest

Complexity

Conditions	1
Paths	1

Size

Total Lines	83
Code Lines	63

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Metric	Value
dl	0
loc	83
ccs	0
cts	65
cp	0
rs	8.7468
cc	1
eloc	63
nc	1
nop	0
crap	2

How to fix Long Method

<?php

/**
 * @package comments
 */
class ElasticSearchPageTest extends ElasticsearchBaseTest {

	public static $fixture_file = 'elastica/tests/ElasticaTest.yml';


	public function testCMSFields() {
		$searchPage = $this->objFromFixture('ElasticSearchPage', 'search');

		$fields = $searchPage->getCMSFields();

		$mainTab = $this->checkTabExists($fields,'Main');
		$this->checkFieldExists($mainTab, 'Identifier');
		$this->checkFieldExists($mainTab, 'ContentForEmptySearch');

		$searchTab = $this->checkTabExists($fields,'Search.SearchFor');
		$fieldsTab = $this->checkTabExists($fields,'Search.Fields');
		$autoCompleteTab = $this->checkTabExists($fields,'Search.AutoComplete');
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
		$aggTab = $this->checkTabExists($fields,'Search.Aggregations');
		$simTab = $this->checkTabExists($fields,'Search.Similarity');

		$this->checkFieldExists($searchTab, 'InfoField');
		$this->checkFieldExists($searchTab, 'SiteTreeOnly');
		$this->checkFieldExists($searchTab, 'ClassesToSearch');
		$this->checkFieldExists($searchTab, 'InfoField');
		$this->checkFieldExists($searchTab, 'SiteTreeOnly');
		$this->checkFieldExists($searchTab, 'ResultsPerPage');

		$this->checkFieldExists($aggTab, 'SearchHelper');

		$this->checkFieldExists($fieldsTab, 'SearchInfo');
		$this->checkFieldExists($fieldsTab, 'ElasticaSearchableFields');

		$this->checkFieldExists($simTab, 'SimilarityNotes');
		$this->checkFieldExists($simTab, 'MinTermFreq');
		$this->checkFieldExists($simTab, 'MaxTermFreq');
		$this->checkFieldExists($simTab, 'MinDocFreq');
		$this->checkFieldExists($simTab, 'MaxDocFreq');
		$this->checkFieldExists($simTab, 'MinWordLength');
		$this->checkFieldExists($simTab, 'MaxWordLength');
		$this->checkFieldExists($simTab, 'MinShouldMatch');

		$form = new Form($this, 'Form', $fields, new FieldList());
function acceptsInteger($int) { }

$x = '123'; // string "123"

// Instead of
acceptsInteger($x);

// we recommend to use
acceptsInteger((integer) $x);

		$tab = $fields->findOrMakeTab("Root.Search.Fields");
		$fieldsTab = $tab->Fields();

		$pickerField = $fieldsTab->fieldByName('ElasticaSearchableFields');
		$pickerConfig = $pickerField->getConfig();
		$gridDetailForm = $pickerConfig->getComponentByType('GridFieldDetailForm');

		$searchableField = $searchPage->ElasticaSearchableFields()->filter(

			array('ClazzName' => 'SiteTree', 'Name' => 'Title')
		)->first();

		$request = new GridFieldDetailForm_ItemRequest(
			GridField::create('ElasticaSearchableFields', 'ElasticaSearchableFields'),
			$gridDetailForm,
			$searchableField,
			new Controller(),
			'Form'
		);
		$form = $request->ItemEditForm();
		$field = $form->Fields()->fieldByName('ClazzName');
		$this->assertEquals('ClazzName', $field->getName());
		$this->assertEquals('SiteTree', $field->Value());

		$field = $form->Fields()->fieldByName('Autocomplete');
		$this->assertEquals('Autocomplete', $field->getName());
		$this->assertEquals(1, $field->Value());

		$field = $form->Fields()->fieldByName('ManyMany[Searchable]');
		$this->assertEquals('ManyMany[Searchable]', $field->getName());
		$this->assertEquals(0, $field->Value());

		$field = $form->Fields()->fieldByName('ManyMany[SimilarSearchable]');
		$this->assertEquals('ManyMany[SimilarSearchable]', $field->getName());
		$this->assertEquals(0, $field->Value());

		$field = $form->Fields()->fieldByName('ManyMany[Weight]');
		$this->assertEquals('ManyMany[Weight]', $field->getName());
		$this->assertEquals('', $field->Value());

		$field = $form->Fields()->fieldByName('ShowHighlights');
		$this->assertEquals('ShowHighlights', $field->getName());
		$this->assertEquals(0, $field->Value());

		$this->assertNotNull($form->Fields()->fieldByName('SecurityID'));
	}


	public function testCannotWriteBlankIdentifier() {
		$esp = new ElasticSearchPage();
		$esp->Title = 'test';
		try {
			$esp->write();
		} catch (ValidationException $e) {
			$this->assertEquals('The identifier cannot be blank', $e->getMessage());
		}
	}


	public function testCannotWriteDuplicateIdentifierDraft() {
		$esp = new ElasticSearchPage();
		$esp->Title = 'test';
		$otherIdentifier = ElasticSearchPage::get()->first()->Identifier;
		$esp->Identifier = $otherIdentifier;
		try {
			$esp->write();
		} catch (ValidationException $e) {
			$this->assertEquals('The identifier testsearchpage already exists', $e->getMessage());
		}
	}


	public function testCannotWriteDuplicateIdentifierLive() {
		$esp = new ElasticSearchPage();
		$esp->Title = 'unique-id';
		$otherIdentifier = ElasticSearchPage::get()->first()->Identifier;
		$esp->Identifier = $otherIdentifier;
		try {
			$esp->write();
			$esp->doPublish();
			$esp->Identifier = $otherIdentifier;
			$esp->write();
		} catch (ValidationException $e) {
			$this->assertEquals('The identifier testsearchpage already exists', $e->getMessage());
		}
	}




		/*
	Test the button override function
	 */
	public function testModelSearchFormAutocompleteAttributes() {
		$searchPageObj = $this->objFromFixture('ElasticSearchPage', 'search');

		$searchPageObj->ClassesToSearch = 'FlickrPhotoTO';
		$filter = array('ClazzName' => 'FlickrPhotoTO', 'Name' => 'Title');
		$sfid = SearchableField::get()->filter($filter)->first()->ID;
		$searchPageObj->AutoCompleteFieldID = $sfid;
		$pageLength = 10; // the default
		$searchPageObj->ResultsPerPage = $pageLength;
		$searchPageObj->write();
		$searchPageObj->publish('Stage','Live');

		$form = $searchPageObj->SearchForm();
		$fields = $form->Fields();
		$q = $fields->fieldByName('q');

		$attributes = $q->getAttributes();
		$expected = array(
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
			'type' => 'text',
			'name' => 'q',
			'value' => '',
			'class' => 'text autocomplete nolabel',
			'id' => 'ElasticSearchForm_SearchForm_q',
			'disabled' => '',
			'readonly' => '',
			'data-autocomplete' => 'true',
			'data-autocomplete-field' => 'Title',
			'data-autocomplete-classes' => 'FlickrPhotoTO',
			'data-autocomplete-sitetree' => '1',
			'data-autocomplete-source' => '/search/',
			'data-autocomplete-function' => '',
			);
		$this->assertEquals($attributes, $attributes);

	}



	/*
	Test the button override function
	 */
	public function testModelSearchFormButtonOverride() {
		$override = 'My Button Override Text';
		$searchPageObj = $this->objFromFixture('ElasticSearchPage', 'search');
		$form = $searchPageObj->SearchForm($override);
		$actions = $form->Actions();
		$button = $actions->fieldByName('action_submit');
		$this->assertEquals($override, $button->Title());

		// no override, use default
		$form = $searchPageObj->SearchForm();
		$actions = $form->Actions();
		$button = $actions->fieldByName('action_submit');
		$this->assertEquals('', $button->Value());
	}



	public function testCannotWriteInvalidClassname() {
		$searchPage = $this->objFromFixture('ElasticSearchPage', 'search');
		$searchPage->ClassesToSearch = 'ThisClassDoesNotExist';
		$searchPage->SiteTreeOnly = false;

		try {
			$searchPage->write();
			$this->fail('Page should not be writeable');
		} catch (ValidationException $e) {
			$this->assertEquals('The class ThisClassDoesNotExist does not exist', $e->getMessage());
		}
	}

	public function testCannotWriteNoSiteTreeOnlyNoClassNames() {
		$searchPage = $this->objFromFixture('ElasticSearchPage', 'search');
		$searchPage->ClassesToSearch = '';
		$searchPage->SiteTreeOnly = false;

		try {
			$searchPage->write();
			$this->fail('Page should not be writeable');
		} catch (ValidationException $e) {
			$this->assertEquals('At least one searchable class must be available, or SiteTreeOnly flag set', $e->getMessage());
		}
	}


	public function testEmptySearchableClass() {
		$searchPage = $this->objFromFixture('ElasticSearchPage', 'search');

		// This does not implement searchable
		$searchPage->ClassesToSearch = '';
		$searchPage->SiteTreeOnly = false;

		try {
			$searchPage->write();
			$this->fail('Page should not be writeable');
		} catch (ValidationException $e) {
			$this->assertEquals(
				'At least one searchable class must be available, or SiteTreeOnly flag set',
				$e->getMessage()
			);
		}
	}


	public function testNonSearchableClass() {
		$searchPage = $this->objFromFixture('ElasticSearchPage', 'search');
		$searchPage->SiteTreeOnly = false;

		// This does not implement searchable
		$searchPage->ClassesToSearch = 'Member';

		try {
			$searchPage->write();
			$this->fail('Page should not be writeable');
		} catch (ValidationException $e) {
			$this->assertEquals('The class Member must have the Searchable extension', $e->getMessage());
		}

		$this->assertEquals(8, $searchPage->ElasticaSearchableFields()->count());


		//Because the write should fail, this will still be the original value of 8
		$this->assertEquals(8, $searchPage->ElasticaSearchableFields()->filter('Active', true)->count());


	}


	/*
	Test setting up a search page for data objects as if editing the CMS directly
	 */
	public function testSearchPageForDataObjects() {
		$searchPage = $this->objFromFixture('ElasticSearchPage', 'search');

		$searchPage->ClassesToSearch = 'FlickrPhotoTO';
		$searchPage->SiteTreeOnly = 0;
		$searchPage->Title = '**** Flickr Photo Search ****';
		$searchPage->write();
		//$searchPage->publish('Stage', 'Live');


		$filter = array('ClazzName' => 'FlickrPhotoTO', 'Name' => 'Title');
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

		//Check fieldnames as expected
		$searchableFields = $searchPage->ElasticaSearchableFields()->filter('Active',1);

		$sfs = $searchableFields->map('Name')->toArray();
		sort($sfs);
		$expected = array('Aperture','AspectRatio','Description','FirstViewed','FlickrID',
			'FlickrSetTOs','FlickrTagTOs','FocalLength35mm','ISO','Photographer','ShutterSpeed',
			'TakenAt', 'TakenAtDT', 'TestMethod', 'TestMethodHTML', 'Title');
		$this->assertEquals($expected, $sfs);


		$searchPage->ClassesToSearch = '';
		$searchPage->SiteTreeOnly = 1;
		$searchPage->Title = '**** SiteTree Search ****';
		$searchPage->write();

		$searchableFields = $searchPage->ElasticaSearchableFields()->filter('Active',1);
		$sfs = $searchableFields->map('Name')->toArray();
		sort($sfs);
		$expected = array('Content', 'Country', 'PageDate', 'Title');
		$this->assertEquals($expected, $sfs);
	}


	/*
	Test that during the build process, requireDefaultRecords creates records for
	each unique field name declared in searchable_fields
	 */
	public function testSearchableFieldsCreatedAtBuildTime() {
		$searchableTestPage = $this->objFromFixture('SearchableTestPage', 'first');
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}
		$searchPage = $this->objFromFixture('ElasticSearchPage', 'search');

		// expected mapping of searchable classes to searchable fields that will be
		// stored in the database as SearchableClass and SearchableField
		$expected = array(
			'Page' => array('Title','Content'),
			'SiteTree' => array('Title','Content'),
			'SearchableTestPage' => array('Title','Content','Country','PageDate'),
			'FlickrTagTO' => array('RawValue'),
			'FlickrAuthorTO' => array('PathAlias','DisplayName','FlickrPhotoTOs'),
			'FlickrPhotoTO' => array('Title','FlickrID','Description','TakenAt', 'TakenAtDT', 'Aperture',
				'ShutterSpeed','FocalLength35mm','ISO','Photographer','FlickrTagTOs','FlickrSetTOs',
				'FirstViewed','AspectRatio', 'TestMethod', 'TestMethodHTML'),
			'FlickrSetTO' => array('Title','FlickrID','Description')
		);

		// check the expected classes
		$expectedClasses = array_keys($expected);
		$nSearchableClasses = SearchableClass::get()->count();
		$this->assertEquals(sizeof($expectedClasses), $nSearchableClasses);


 		$searchPage->SiteTreeOnly = true;
		$searchPage->Content = 'some random string';
		$searchPage->write();
		$scs = SearchableClass::get();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

		$sfs = $searchPage->SearchableFields();
$myVar = 'Value';
$higher = false;

if (rand(1, 6) > 3) {
    $higher = true;
} else {
    $higher = false;
}

		// check the names expected to appear
		$fieldCtr = 0;
		foreach ($expectedClasses as $expectedClass) {
			$expectedFields = array();
			$sc = SearchableClass::get()->filter('Name', $expectedClass)->first();
			$this->assertEquals($expectedClass,$sc->Name);

			$inSiteTree = 1;
			$start = substr($expectedClass, 0,6);
			if ($start == 'Flickr') {
				$inSiteTree = 0;
			};
			$this->assertEquals($inSiteTree,$sc->InSiteTree);

			$expectedNames = $expected[$expectedClass];
			foreach ($expectedNames as $expectedName) {
				$filter = array('Name' => $expectedName, 'SearchableClassID' => $sc->ID );
				$sf = SearchableField::get()->filter($filter)->first();
				$this->assertEquals($expectedName, $sf->Name);
				$fieldCtr++;
				array_push($expectedFields, $expectedName);
			}
		}
		$nSearchableFields = SearchableField::get()->count();

		$this->assertEquals($fieldCtr, $nSearchableFields);
	}


	public function testGetCMSValidator() {
		$searchPage = $this->objFromFixture('ElasticSearchPage', 'search');
		$validator = $searchPage->getCMSValidator();
		$this->assertEquals('ElasticSearchPage_Validator', get_class($validator));
	}


	public function testValidateClassesToSearchNonExistent() {
		$searchPage = $this->objFromFixture('ElasticSearchPage', 'search');
		$searchPage->ClassesToSearch = 'WibbleWobble'; // does not exist
		$searchPage->SiteTreeOnly = false;
		try {
			$searchPage->write();
			$this->fail('Test should have failed as WibbleWobble is not a valid class');
		} catch (ValidationException $e) {
			$this->assertEquals('The class WibbleWobble does not exist', $e->getMessage());
		}
	}


	public function testValidateClassesToSearchNotSearchable() {
		$searchPage = $this->objFromFixture('ElasticSearchPage', 'search');
		$searchPage->ClassesToSearch = 'member'; // does not implement Searchable
		$searchPage->SiteTreeOnly = false;
		try {
			$searchPage->write();
			$this->fail('Test should have failed as WibbleWobble is not a valid class');
		} catch (ValidationException $e) {
			$this->assertEquals('The class member must have the Searchable extension', $e->getMessage());
		}
	}
}


1			<?php
2
3			/**
4			* @package comments
5			*/
6			class ElasticSearchPageTest extends ElasticsearchBaseTest {
7
8			public static $fixture_file = 'elastica/tests/ElasticaTest.yml';
9
10
11			public function testCMSFields() {
12			$searchPage = $this->objFromFixture('ElasticSearchPage', 'search');
13
14			$fields = $searchPage->getCMSFields();
15
16			$mainTab = $this->checkTabExists($fields,'Main');
17			$this->checkFieldExists($mainTab, 'Identifier');
18			$this->checkFieldExists($mainTab, 'ContentForEmptySearch');
19
20			$searchTab = $this->checkTabExists($fields,'Search.SearchFor');
21			$fieldsTab = $this->checkTabExists($fields,'Search.Fields');
22			$autoCompleteTab = $this->checkTabExists($fields,'Search.AutoComplete');
			0 ignored issues – show Unused Code introduced 2015-12-01 14:39 UTC by Report Bug Copy Issue Report `$autoCompleteTab` is not used, you could remove the assignment. This check looks for variable assignements that are either overwritten by other assignments or where the variable is not used subsequently. $myVar = 'Value'; $higher = false; if (rand(1, 6) > 3) { $higher = true; } else { $higher = false; } Both the `$myVar` assignment in line 1 and the `$higher` assignment in line 2 are dead. The first because `$myVar` is never used and the second because `$higher` is always overwritten for every possible time line. Loading history...
23			$aggTab = $this->checkTabExists($fields,'Search.Aggregations');
24			$simTab = $this->checkTabExists($fields,'Search.Similarity');
25
26			$this->checkFieldExists($searchTab, 'InfoField');
27			$this->checkFieldExists($searchTab, 'SiteTreeOnly');
28			$this->checkFieldExists($searchTab, 'ClassesToSearch');
29			$this->checkFieldExists($searchTab, 'InfoField');
30			$this->checkFieldExists($searchTab, 'SiteTreeOnly');
31			$this->checkFieldExists($searchTab, 'ResultsPerPage');
32
33			$this->checkFieldExists($aggTab, 'SearchHelper');
34
35			$this->checkFieldExists($fieldsTab, 'SearchInfo');
36			$this->checkFieldExists($fieldsTab, 'ElasticaSearchableFields');
37
38			$this->checkFieldExists($simTab, 'SimilarityNotes');
39			$this->checkFieldExists($simTab, 'MinTermFreq');

gordonbanderson / silverstripe-elastica

ElasticSearchPageTest::testCMSFields() B last analyzed 2016-01-04 04:20 UTC

Complexity

Size

Duplication

Code Coverage

How to fix Long Method

Long Method

Duplication Side-by-Side

Filter issues like

ElasticSearchPageTest::testCMSFields() B
last analyzed 2016-01-04 04:20 UTC