public void Concat_different_types() {
     var q1 = new SolrQuery("1");
     var q2 = new SolrQueryByField("f", "v");
     var qm = new SolrMultipleCriteriaQuery(new ISolrQuery[] {q1, q2});
     Console.WriteLine(Serialize(qm));
     Assert.AreEqual("(1  f:(v))", Serialize(qm));
 }

 public void AcceptsNulls()
 {
     var q1 = new SolrQuery("1");
     ISolrQuery q2 = null;
     var qm = new SolrMultipleCriteriaQuery(new[] {q1, q2});
     Assert.AreEqual("(1)", Serialize(qm));
 }

 public async Task Facet1Async()
 {
     var termsFacetFor = new SolrQuery<TechProduct>().SearchFor("*", "lucene").Take(0).TermsFacetFor(x => x.Category);
     termsFacetFor = termsFacetFor.RangeFacetFor(x => x.Popularity, x => x.Range(5, 10, "1"));
     termsFacetFor = termsFacetFor.RangeFacetFor(x => x.ManufactureDate,
         x =>
             x.Range(DateTime.Now.AddYears(-20), DateTime.Now, "+1YEAR")
                 .TermsFacetFor(y => y.Category,
                     y => y.RangeFacetFor(z => z.Popularity, z => z.Range(5, 10, "1"))));
     var searchResult = await _repository.SearchAsync(termsFacetFor);
     var bucket = searchResult.Raw.Facets["R2"]["buckets"].ToList()[10]["T0"]["buckets"].ToList()[0]["R0"]["buckets"].ToList()[1];
     Assert.AreEqual(6, bucket["val"]);
     Assert.AreEqual(2, bucket["count"]);
     //var facetC = new SolrQueryStatisticsFacet<TechProduct>("unique(cat)");
     //var facetA = new SolrQueryTermsFacet<TechProduct>(x => x.Category).Facet("D", facetC);
     //var facetB = new SolrQueryTermsFacet<TechProduct>(x => x.LastModified).Facet("D", facetC);
     //var query = new SolrQuery<TechProduct>().Take(0).Facet("A", facetA).Facet("B", facetB).Facet("C", facetC);
     //var r3 = await _repository.Get(query);
     //Assert.AreEqual(0, r3.Response.Documents.Count());
     //var facets = r3.GetFacets();
     //Assert.AreEqual(37, (long)r3.Facets["count"]);
     //var facetObject = (JObject)r3.Facets["A"];
     //var dic = facetObject.ToObject<IDictionary>();
     //Assert.AreNotEqual(null, dic);
 }

 public void Concat()
 {
     var q1 = new SolrQuery("1");
     var q2 = new SolrQuery("2");
     var qm = new SolrMultipleCriteriaQuery(new[] {q1, q2});
     Assert.AreEqual("(1  2)", Serialize(qm));
 }

 public void SolrQuery_Boost()
 {
     var q = new SolrQuery("solr").Boost(12.2);
     var serializer = new DefaultQuerySerializer(new DefaultFieldSerializer());
     var query = serializer.Serialize(q);
     Assert.AreEqual("(solr)^12.2", query);
 }

 public void PlusEqualMany() {
     AbstractSolrQuery q = new SolrQuery("first");
     foreach (var _ in Enumerable.Range(0, 10)) {
         q += new SolrQuery("others");
     }
     Assert.AreEqual("((((((((((first  others)  others)  others)  others)  others)  others)  others)  others)  others)  others)", Serialize(q));
 }

        public IPagedResult<IResult> Users(string name, uint pageIndex = 0, uint pageSize = 10)
        {
            var q = new SolrQuery
                {
                    Query = string.Format("(Name:{0}*)(Name_split:{0}*)", name.ToLower().Replace(" ", "\\ ")),
                    PageIndex = pageIndex,
                    PageSize = pageSize
                };
            var results = ViewManager.GetView("UserSearch").Query(q);

            return results;
        }

        public QueryResult Facet(string query, string facetField)
        {
            var q = new SolrQuery
                {
                    Query = query,
                    Facet = string.Format("field:{0}", facetField)
                };
            
            var result = ViewManager.GetView("Search").FacetedQuery(q);
            var fieldFacets = result.FacetFieldsResult.Select(item => new FieldFacet(item.Value, item.Facets.Select(facet => new Facet(facet.Value, facet.Count)).ToList()));

            return new QueryResult { FieldFacets = fieldFacets.ToList() };
        }

        public void Get_WithObjectTypeQuery_ShouldQueryViewWithObjectTypeIdAndFolders()
        {
            var extension  = Make_ObjectV5Extension();
            var folder     = new Folder{ID = 1};
            var user       = Make_User();
            var query      = new SolrQuery {Query = "ObjectTypeID:1"};
            PortalApplication.Setup(m => m.Log.Debug(It.IsAny<string>(), null)); 
            ViewManager.Setup(m => m.GetView("Object").Query(It.Is<IQuery>(q => q.Query == "(ObjectTypeId:1)AND((FolderAncestors:1))"))).Returns(new PagedResult<IResult>(0, 0, new IResult[0]));
            PortalRequest.SetupGet(p => p.User).Returns(user);
            PermissionManager.Setup(m => m.GetFolders(FolderPermission.Read, user.Guid, It.IsAny<IEnumerable<Guid>>())).Returns(new[] { folder });

            extension.Get(query, null, true, true, true, true);

            ViewManager.Verify(m => m.GetView("Object").Query(It.Is<IQuery>(q => q.Query == "(ObjectTypeId:1)AND((FolderAncestors:1))")));
        }

		public void DeleteByQuery() {
            const string queryString = "someQuery";
		    var q = new SolrQuery(queryString);
            var xml = string.Format("<delete><query>{0}</query></delete>", queryString);

		    var conn = new Mocks.MSolrConnection();
		    conn.post = conn.post.Args("/update", xml);

		    var querySerializer = new Mocks.MSolrQuerySerializer();
		    querySerializer.serialize += _ => queryString;

            var cmd = new DeleteCommand(new DeleteByIdAndOrQueryParam(null, q, querySerializer), null);
            cmd.Execute(conn);

            Assert.AreEqual(1, conn.post.Calls);
		}

        public void DeleteByIdAndQuery()
        {
            var ids = new[] { "123", "456" };
            const string queryString = "someQuery";
            var xml = string.Format("<delete><id>{0}</id><id>{1}</id><query>{2}</query></delete>", ids[0], ids[1], queryString);
            var conn = new Mocks.MSolrConnection();
            conn.post = conn.post.Args("/update", xml);

            var q = new SolrQuery(queryString);
            var querySerializer = new Mocks.MSolrQuerySerializer();
            querySerializer.serialize += _ => queryString;

            var cmd = new DeleteCommand(new DeleteByIdAndOrQueryParam(ids, q, querySerializer));
            cmd.Execute(conn);

            Assert.AreEqual(1, conn.post.Calls);
        }

        public IPagedResult<IResult> Get(IEnumerable<Guid> objectGuids, uint? folderId = null, Guid? accessPointGuid = null, bool includeAccessPoints = false, bool includeMetadata = false, bool includeFiles = false, bool includeObjectRelations = false, bool includeFolders = false, uint pageSize = 10, uint pageIndex = 0)
        {
            var query = new SolrQuery
                {
                    Query = "*:*", 
                    PageIndex = pageIndex, 
                    PageSize = pageSize
                };

            if (objectGuids.Any()) query.Query = string.Format("Id:{0}", string.Join(" ", objectGuids));

            var folderFilter = GetFoldersWithAccess(folderId);

            if(accessPointGuid == null && !folderFilter.Any()) throw new InsufficientPermissionsException("No folders with access");

            return ObjectQueryHelper.GetObjects(query, accessPointGuid, folderFilter,
                                                                       includeAccessPoints, includeMetadata,
                                                                       includeFiles, includeObjectRelations,
                                                                       includeFolders);
        }

 public void Minus()
 {
     var q = new SolrQuery("solr") - new SolrQuery("name:desc");
     Assert.AreEqual("(solr  -name:desc)", Serialize(q));
 }

 public void AndNot()
 {
     var q = new SolrQuery("a") && !new SolrQuery("b");
     Console.WriteLine(Serialize(q));
     Assert.AreEqual("(a AND -b)", Serialize(q));
 }

 public void Add()
 {
     var q = new SolrQuery("solr") + new SolrQuery("name:desc");
     Assert.AreEqual("(solr  name:desc)", Serialize(q));
 }

 public void OneOr()
 {
     var q = new SolrQuery("solr") || new SolrQuery("name:desc");
     Assert.AreEqual("(solr OR name:desc)", Serialize(q));
 }

 public void SolrQuery_Boost()
 {
     var q = new SolrQuery("solr").Boost(12.2);
     Assert.AreEqual("(solr)^12.2", q.Query);
 }

 public void MultipleOr()
 {
     var q = new SolrQuery("solr") || new SolrQuery("name:desc") || new SolrQueryByField("id", "123456");
     Assert.AreEqual("((solr OR name:desc) OR id:(123456))", Serialize(q));
 }

 public void Add()
 {
     var q = new SolrQuery("solr") + new SolrQuery("name:desc");
     Assert.AreEqual("(solr  name:desc)", q.Query);
 }

 public void RequiredQuery_is_AbstractSolrQuery() {
     AbstractSolrQuery q = new SolrQuery("").Required();
 }