public function testToHttpRequestWithDefaultContentType()
{
$request = new Solarium_Client_Request();
$request->setMethod(Solarium_Client_Request::METHOD_POST);
$httpRequest = $this->_adapter->toHttpRequest($request);
$this->assertEquals(array('timeout' => 10, 'headers' => array('Content-Type' => 'text/xml; charset=utf-8')), $httpRequest->getOptions());
}
/**
* Add request settings for the debug component
*
* @param Solarium_Query_Select_Component_Debug $component
* @param Solarium_Client_Request $request
* @return Solarium_Client_Request
*/
public function build($component, $request)
{
$request->addParam('debugQuery', 'true');
$request->addParam('debug.explain.structured', 'true');
$request->addParam('explainOther', $component->getExplainOther());
return $request;
}
/**
* Build request for a select query
*
* @param Solarium_Query $query
* @return Solarium_Client_Request
*/
public function build($query)
{
$request = new Solarium_Client_Request();
$request->setHandler($query->getHandler());
$request->addParams($query->getParams());
$request->addParam('wt', 'json');
return $request;
}
/**
* Build request for a ping query
*
* @param Solarium_Query_Ping $query
* @return Solarium_Client_Request
*/
public function build($query)
{
$request = new Solarium_Client_Request();
$request->setHandler($query->getHandler());
$request->setMethod(Solarium_Client_Request::METHOD_GET);
$request->addParam('wt', 'json');
return $request;
}
/**
* Add request settings for DistributedSearch
*
* @param Solarium_Query_Select_Component_DistributedSearch $component
* @param Solarium_Client_Request $request
* @return Solarium_Client_Request
*/
public function build($component, $request)
{
// add shard fields to request
$shards = array_values($component->getShards());
if (count($shards)) {
$request->addParam('shards', implode(',', $shards));
}
$request->addParam('shards.qt', $component->getShardRequestHandler());
return $request;
}
public function testGetUriWithHandlerAndParams()
{
$params = array('param1' => 1, 'param2' => array(2, 3));
$this->_request->setHandler('myHandler');
$this->_request->addParams($params);
$this->assertEquals('myHandler?param1=1¶m2=2¶m2=3', $this->_request->getUri());
}
/**
* Create a stream context for a request
*
* @param Solarium_Client_Request $request
* @return resource
*/
public function createContext($request)
{
$method = $request->getMethod();
$context = stream_context_create(array('http' => array('method' => $method, 'timeout' => $this->getTimeout())));
if ($method == Solarium_Client_Request::METHOD_POST) {
$data = $request->getRawData();
if (null !== $data) {
stream_context_set_option($context, 'http', 'content', $data);
$request->addHeader('Content-Type: text/xml; charset=UTF-8');
}
}
$headers = $request->getHeaders();
if (count($headers) > 0) {
stream_context_set_option($context, 'http', 'header', implode("\r\n", $headers));
}
return $context;
}
/**
* Event hook to adjust client settings just before query execution
*
* @param Solarium_Query $query
* @param Solarium_Client_Request $request
* @return void
*/
public function postCreateRequest($query, $request)
{
$queryString = $request->getQueryString();
if ($request->getMethod() == Solarium_Client_Request::METHOD_GET && strlen($queryString) > $this->getMaxQueryStringLength()) {
$request->setMethod(Solarium_Client_Request::METHOD_POST);
$request->setRawData($queryString);
$request->clearParams();
$request->addHeader('Content-Type: application/x-www-form-urlencoded');
}
}
/**
* Build request for an analysis query
*
* @param Solarium_Query_Analysis $query
* @return Solarium_Client_Request
*/
public function build($query)
{
$request = new Solarium_Client_Request();
$request->setHandler($query->getHandler());
$request->addParam('wt', 'json');
$request->addParam('analysis.query', $query->getQuery());
$request->addParam('analysis.showmatch', $query->getShowMatch());
return $request;
}
public function testToString()
{
$options = array('method' => Solarium_Client_Request::METHOD_POST, 'handler' => '/myHandler', 'param' => array('param1' => 1, 'param2' => 'test content'), 'rawdata' => 'post data', 'header' => array('myHeader1' => 'X-myHeader1: value1', 'myHeader2' => 'X-myHeader2: value2'));
$this->_request->setOptions($options);
$this->assertEquals('Solarium_Client_Request::toString
method: POST
header: Array
(
[0] => X-myHeader1: value1
[1] => X-myHeader2: value2
)
resource: /myHandler?param1=1¶m2=test+content
resource urldecoded: /myHandler?param1=1¶m2=test content
raw data: post data
', (string) $this->_request);
}
/**
* Build request for a select query
*
* @param Solarium_Query_Select $query
* @return Solarium_Client_Request
*/
public function build($query)
{
$request = new Solarium_Client_Request();
$request->setHandler($query->getHandler());
// add basic params to request
$request->addParam('q', $query->getQuery());
$request->addParam('start', $query->getStart());
$request->addParam('rows', $query->getRows());
$request->addParam('fl', implode(',', $query->getFields()));
$request->addParam('wt', 'json');
// add sort fields to request
$sort = array();
foreach ($query->getSorts() as $field => $order) {
$sort[] = $field . ' ' . $order;
}
if (count($sort) !== 0) {
$request->addParam('sort', implode(',', $sort));
}
// add filterqueries to request
$filterQueries = $query->getFilterQueries();
if (count($filterQueries) !== 0) {
foreach ($filterQueries as $filterQuery) {
$fq = $this->renderLocalParams($filterQuery->getQuery(), array('tag' => $filterQuery->getTags()));
$request->addParam('fq', $fq);
}
}
// add components to request
$types = $query->getComponentTypes();
foreach ($query->getComponents() as $component) {
$componentBuilderClass = $types[$component->getType()]['requestbuilder'];
if (!empty($componentBuilderClass)) {
$componentBuilder = new $componentBuilderClass();
$request = $componentBuilder->build($component, $request);
}
}
return $request;
}
/**
* Add request settings for the stats component
*
* @param Solarium_Query_Select_Component_Stats $component
* @param Solarium_Client_Request $request
* @return Solarium_Client_Request
*/
public function build($component, $request)
{
// enable stats
$request->addParam('stats', 'true');
// add fields
foreach ($component->getFields() as $field) {
$request->addParam('stats.field', $field->getKey());
// add field specific facet stats
foreach ($field->getFacets() as $facet) {
$request->addParam('f.' . $field->getKey() . '.stats.facet', $facet);
}
}
// add facet stats for all fields
foreach ($component->getFacets() as $facet) {
$request->addParam('stats.facet', $facet);
}
return $request;
}
public function testCreateContextPostRequest()
{
$timeout = 13;
$method = Solarium_Client_Request::METHOD_POST;
$data = 'test123';
$request = new Solarium_Client_Request();
$request->setMethod($method);
$request->setRawData($data);
$this->_adapter->setTimeout($timeout);
$context = $this->_adapter->createContext($request);
$this->assertEquals(array('http' => array('method' => $method, 'timeout' => $timeout, 'content' => $data, 'header' => 'Content-Type: text/xml; charset=UTF-8')), stream_context_get_options($context));
}
/**
* Add request settings for Spellcheck
*
* @param Solarium_Query_Select_Component_Spellcheck $component
* @param Solarium_Client_Request $request
* @return Solarium_Client_Request
*/
public function buildComponent($component, $request)
{
// enable spellcheck
$request->addParam('spellcheck', 'true');
$request->addParam('spellcheck.q', $component->getQuery());
$request->addParam('spellcheck.build', $component->getBuild());
$request->addParam('spellcheck.reload', $component->getReload());
$request->addParam('spellcheck.dictionary', $component->getDictionary());
$request->addParam('spellcheck.count', $component->getCount());
$request->addParam('spellcheck.onlyMorePopular', $component->getOnlyMorePopular());
$request->addParam('spellcheck.extendedResults', $component->getExtendedResults());
$request->addParam('spellcheck.collate', $component->getCollate());
$request->addParam('spellcheck.maxCollations', $component->getMaxCollations());
$request->addParam('spellcheck.maxCollationTries', $component->getMaxCollationTries());
$request->addParam('spellcheck.maxCollationEvaluations', $component->getMaxCollationEvaluations());
$request->addParam('spellcheck.collateExtendedResults', $component->getCollateExtendedResults());
$request->addParam('spellcheck.accuracy', $component->getAccuracy());
return $request;
}
/**
* Create http request options from request.
*
* @param Solarium_Client_Request $request
* @return array
*/
protected function _createOptions($request)
{
// @codeCoverageIgnoreStart
$options = array('timeout' => $this->getTimeout());
foreach ($request->getHeaders() as $headerLine) {
list($header, $value) = explode(':', $headerLine);
if ($header = trim($header)) {
$options['headers'][$header] = trim($value);
}
}
return $options;
// @codeCoverageIgnoreEnd
}
/**
* Execute a Solr request using the Zend_Http_Client instance
*
* @param Solarium_Client_Request $request
* @return Solarium_Client_Response
*/
public function execute($request)
{
$client = $this->getZendHttp();
$client->setMethod($request->getMethod());
$client->setUri($this->getBaseUri() . $request->getUri());
$client->setHeaders($request->getHeaders());
$client->setRawData($request->getRawData());
$response = $client->request();
// throw an exception in case of a HTTP error
if ($response->isError()) {
throw new Solarium_Client_HttpException($response->getMessage(), $response->getStatus());
}
if ($request->getMethod() == Solarium_Client_Request::METHOD_HEAD) {
$data = '';
} else {
$data = $response->getBody();
}
// this is used because getHeaders doesn't return the HTTP header...
$headers = explode("\n", $response->getHeadersAsString());
return new Solarium_Client_Response($data, $headers);
}
public function testExecuteHeadRequestReturnsNoData()
{
$request = new Solarium_Client_Request();
$request->setMethod(Solarium_Client_Request::METHOD_HEAD);
$response = new Zend_Http_Response(200, array('status' => 'HTTP 1.1 200 OK'), 'data');
$mock = $this->getMock('Zend_Http_Client');
$mock->expects($this->once())->method('request')->will($this->returnValue($response));
$this->_adapter->setZendHttp($mock);
$response = $this->_adapter->execute($request);
$this->assertEquals('', $response->getBody());
}
/**
* Add request settings for Dismax
*
* @param Solarium_Query_Select_Component_Dismax $component
* @param Solarium_Client_Request $request
* @return Solarium_Client_Request
*/
public function buildComponent($component, $request)
{
// enable dismax
$request->addParam('defType', $component->getQueryParser());
$request->addParam('q.alt', $component->getQueryAlternative());
$request->addParam('qf', $component->getQueryFields());
$request->addParam('mm', $component->getMinimumMatch());
$request->addParam('pf', $component->getPhraseFields());
$request->addParam('ps', $component->getPhraseSlop());
$request->addParam('qs', $component->getQueryPhraseSlop());
$request->addParam('tie', $component->getTie());
$request->addParam('bq', $component->getBoostQuery());
$request->addParam('bf', $component->getBoostFunctions());
return $request;
}
/**
* Add params for a range facet to request
*
* @param Solarium_Client_Request $request
* @param Solarium_Query_Select_Component_Facet_Range $facet
* @return void
*/
public function addFacetRange($request, $facet)
{
$field = $facet->getField();
$request->addParam('facet.range', $this->renderLocalParams($field, array('key' => $facet->getKey(), 'ex' => $facet->getExcludes())));
$request->addParam("f.{$field}.facet.range.start", $facet->getStart());
$request->addParam("f.{$field}.facet.range.end", $facet->getEnd());
$request->addParam("f.{$field}.facet.range.gap", $facet->getGap());
$request->addParam("f.{$field}.facet.range.hardend", $facet->getHardend());
if (null !== $facet->getOther()) {
$other = explode(',', $facet->getOther());
foreach ($other as $otherValue) {
$request->addParam("f.{$field}.facet.range.other", trim($otherValue));
}
}
if (null !== $facet->getInclude()) {
$include = explode(',', $facet->getInclude());
foreach ($include as $includeValue) {
$request->addParam("f.{$field}.facet.range.include", trim($includeValue));
}
}
}
/**
* Add request settings for morelikethis
*
* @param Solarium_Query_Select_Component_MoreLikeThis $component
* @param Solarium_Client_Request $request
* @return Solarium_Client_Request
*/
public function build($component, $request)
{
// enable morelikethis
$request->addParam('mlt', 'true');
$request->addParam('mlt.fl', $component->getFields());
$request->addParam('mlt.mintf', $component->getMinimumTermFrequency());
$request->addParam('mlt.mindf', $component->getMinimumDocumentFrequency());
$request->addParam('mlt.minwl', $component->getMinimumWordLength());
$request->addParam('mlt.maxwl', $component->getMaximumWordLength());
$request->addParam('mlt.maxqt', $component->getMaximumQueryTerms());
$request->addParam('mlt.maxntp', $component->getMaximumNumberOfTokens());
$request->addParam('mlt.boost', $component->getBoost());
$request->addParam('mlt.qf', $component->getQueryFields());
$request->addParam('mlt.count', $component->getCount());
return $request;
}
/**
* Event hook to customize the request object
*
* @param Solarium_Query $query
* @param Solarium_Client_Request $request
* @return void
*/
public function postCreateRequest($query, $request)
{
foreach ($this->getCustomizations() as $key => $customization) {
// first validate
if (!$customization->isValid()) {
throw new Solarium_Exception('Request customization with key "' . $key . '" is invalid');
}
// apply to request, depending on type
switch ($customization->getType()) {
case Solarium_Plugin_CustomizeRequest_Customization::TYPE_PARAM:
$request->addParam($customization->getName(), $customization->getValue(), $customization->getOverwrite());
break;
case Solarium_Plugin_CustomizeRequest_Customization::TYPE_HEADER:
$request->addHeader($customization->getName() . ': ' . $customization->getValue());
break;
}
// remove single-use customizations after use
if (!$customization->getPersistent()) {
$this->removeCustomization($key);
}
}
}
/**
* Build request for a Terms query
*
* @param Solarium_Query_Terms $query
* @return Solarium_Client_Request
*/
public function build($query)
{
$request = new Solarium_Client_Request();
$request->setHandler($query->getHandler());
$request->addParam('terms', true);
$request->addParam('wt', 'json');
$request->addParam('terms.lower', $query->getLowerbound());
$request->addParam('terms.lower.incl', $query->getLowerboundInclude());
$request->addParam('terms.mincount', $query->getMinCount());
$request->addParam('terms.maxcount', $query->getMaxCount());
$request->addParam('terms.prefix', $query->getPrefix());
$request->addParam('terms.regex', $query->getRegex());
$request->addParam('terms.limit', $query->getLimit());
$request->addParam('terms.upper', $query->getUpperbound());
$request->addParam('terms.upper.incl', $query->getUpperboundInclude());
$request->addParam('terms.raw', $query->getRaw());
$request->addParam('terms.sort', $query->getSort());
$fields = explode(',', $query->getFields());
foreach ($fields as $field) {
$request->addParam('terms.fl', trim($field));
}
if ($query->getRegexFlags() !== null) {
$flags = explode(',', $query->getRegexFlags());
foreach ($flags as $flag) {
$request->addParam('terms.regex.flag', trim($flag));
}
}
return $request;
}
/**
*
* adapt Solarium_Client_Request to HttpRequest
*
* {@link http://us.php.net/manual/en/http.constants.php
* HTTP Predefined Constant}
*
* @param Solarium_Client_Request $request
* @param HttpRequest
*/
public function toHttpRequest($request)
{
$url = $this->getBaseUri() . $request->getUri();
$httpRequest = new HttpRequest($url);
$headers = array();
foreach ($request->getHeaders() as $headerLine) {
list($header, $value) = explode(':', $headerLine);
if ($header = trim($header)) {
$headers[$header] = trim($value);
}
}
switch ($request->getMethod()) {
case Solarium_Client_Request::METHOD_GET:
$method = HTTP_METH_GET;
break;
case Solarium_Client_Request::METHOD_POST:
$method = HTTP_METH_POST;
$httpRequest->setBody($request->getRawData());
if (!isset($headers['Content-Type'])) {
$headers['Content-Type'] = 'text/xml; charset=utf-8';
}
break;
case Solarium_Client_Request::METHOD_HEAD:
$method = HTTP_METH_HEAD;
break;
default:
throw new Solarium_Exception('Unsupported method: ' . $request->getMethod());
}
$httpRequest->setMethod($method);
$httpRequest->setOptions(array('timeout' => $this->getTimeout()));
$httpRequest->setHeaders($headers);
return $httpRequest;
}
/**
* Add request settings for Highlighting
*
* @param Solarium_Query_Select_Component_Highlighting $component
* @param Solarium_Client_Request $request
* @return Solarium_Client_Request
*/
public function build($component, $request)
{
// enable highlighting
$request->addParam('hl', 'true');
$request->addParam('hl.fl', $component->getFields());
$request->addParam('hl.snippets', $component->getSnippets());
$request->addParam('hl.fragsize', $component->getFragSize());
$request->addParam('hl.mergeContiguous', $component->getMergeContiguous());
$request->addParam('hl.requireFieldMatch', $component->getRequireFieldMatch());
$request->addParam('hl.maxAnalyzedChars', $component->getMaxAnalyzedChars());
$request->addParam('hl.alternateField', $component->getAlternateField());
$request->addParam('hl.maxAlternateFieldLength', $component->getMaxAlternateFieldLength());
$request->addParam('hl.formatter', $component->getFormatter());
$request->addParam('hl.simple.pre', $component->getSimplePrefix());
$request->addParam('hl.simple.post', $component->getSimplePostfix());
$request->addParam('hl.fragmenter', $component->getFragmenter());
$request->addParam('hl.fragListBuilder', $component->getFragListBuilder());
$request->addParam('hl.fragmentsBuilder', $component->getFragmentsBuilder());
$request->addParam('hl.useFastVectorHighlighter', $component->getUseFastVectorHighlighter());
$request->addParam('hl.usePhraseHighlighter', $component->getUsePhraseHighlighter());
$request->addParam('hl.highlightMultiTerm', $component->getHighlightMultiTerm());
$request->addParam('hl.regex.slop', $component->getRegexSlop());
$request->addParam('hl.regex.pattern', $component->getRegexPattern());
$request->addParam('hl.regex.maxAnalyzedChars', $component->getRegexMaxAnalyzedChars());
return $request;
}
/**
* Add request settings for Grouping
*
* @param Solarium_Query_Select_Component_Grouping $component
* @param Solarium_Client_Request $request
* @return Solarium_Client_Request
*/
public function build($component, $request)
{
// enable grouping
$request->addParam('group', 'true');
$request->addParam('group.field', $component->getFields());
$request->addParam('group.query', $component->getQueries());
$request->addParam('group.limit', $component->getLimit());
$request->addParam('group.offset', $component->getOffset());
$request->addParam('group.sort', $component->getSort());
$request->addParam('group.main', $component->getMainResult());
$request->addParam('group.ngroups', $component->getNumberOfGroups());
$request->addParam('group.cache.percent', $component->getCachePercentage());
$request->addParam('group.truncate', $component->getTruncate());
return $request;
}
/**
* Add per-field override options to the request
*
* @param Solarium_Query_Select_Component_Highlighting_Field $field
* @param Solarium_Client_Request $request
* @return void
*/
protected function _addFieldParams($field, $request)
{
$prefix = 'f.' . $field->getName() . '.hl.';
$request->addParam($prefix . 'snippets', $field->getSnippets());
$request->addParam($prefix . 'fragsize', $field->getFragSize());
$request->addParam($prefix . 'mergeContiguous', $field->getMergeContiguous());
$request->addParam($prefix . 'alternateField', $field->getAlternateField());
$request->addParam($prefix . 'formatter', $field->getFormatter());
$request->addParam($prefix . 'simple.pre', $field->getSimplePrefix());
$request->addParam($prefix . 'simple.post', $field->getSimplePostfix());
$request->addParam($prefix . 'fragmenter', $field->getFragmenter());
$request->addParam($prefix . 'useFastVectorHighlighter', $field->getUseFastVectorHighlighter());
}
