コード例 #1
0
        public void Ranked_search_hits_lucene_and_caches_result()
        {
            var  searchMock   = CreateMocks().Item1;
            var  luceneMock   = MockPlug.Setup(Utils.Settings.LuceneMockUri);
            var  before       = DateTime.UtcNow.AddDays(-2).WithoutMilliseconds();
            var  since        = DateTime.UtcNow.AddDays(-1).WithoutMilliseconds();
            uint limit        = 10;
            uint offset       = 20;
            var  responseXml  = new XDoc("response");
            var  luceneXml    = new XDoc("lucene");
            var  searchQuery  = new SearchQuery("raw", "processed", new LuceneClauseBuilder(), null);
            var  searchResult = new SearchResult();

            searchMock.Setup(x => x.BuildQuery("foo", "", SearchQueryParserType.BestGuess, false)).Returns(searchQuery).AtMostOnce().Verifiable();
            searchMock.Setup(x => x.GetCachedQuery(searchQuery)).Returns((SearchResult)null).AtMostOnce().Verifiable();
            luceneMock
            .Verb("GET")
            .At("compact")
            .With("wikiid", "default")
            .With("q", searchQuery.LuceneQuery)
            .Returns(luceneXml)
            .ExpectCalls(DreamTimes.Once());
            searchMock.Setup(x => x.CacheQuery(It.Is <XDoc>(v => v == luceneXml), searchQuery, It.Is <TrackingInfo>(t => !t.QueryId.HasValue)))
            .Returns(searchResult)
            .AtMostOnce()
            .Verifiable();
            Predicate <SetDiscriminator> discriminator = s => {
                return(s.Limit == limit && s.Offset == offset && s.SortField == "rank" && !s.Ascending);
            };

            searchMock.Setup(x => x.FormatResultSet(
                                 searchResult,
                                 It.Is <SetDiscriminator>(s => discriminator(s)),
                                 false,
                                 It.Is <TrackingInfo>(t => !t.QueryId.HasValue),
                                 It.IsAny <Result <XDoc> >()
                                 ))
            .Returns(new Result <XDoc>().WithReturn(responseXml))
            .AtMostOnce()
            .Verifiable();
            var response = _search
                           .With("q", "foo")
                           .With("since", since)
                           .With("before", before)
                           .With("limit", limit)
                           .With("offset", offset)
                           .Get(new Result <DreamMessage>()).Wait();

            Assert.IsTrue(response.IsSuccessful, response.ToErrorString());
            searchMock.VerifyAll();
            luceneMock.Verify();
            Assert.AreEqual(responseXml, response.ToDocument());
        }
コード例 #2
0
        public void Ranked_search_tracks_previous_queryid()
        {
            var   searchMock      = CreateMocks().Item1;
            var   luceneMock      = MockPlug.Setup(Utils.Settings.LuceneMockUri);
            var   before          = DateTime.UtcNow.AddDays(-2).WithoutMilliseconds();
            var   since           = DateTime.UtcNow.AddDays(-1).WithoutMilliseconds();
            uint  limit           = 10;
            uint  offset          = 20;
            ulong previousqueryid = 43;
            var   responseXml     = new XDoc("response");
            var   luceneXml       = new XDoc("lucene");
            var   searchQuery     = new SearchQuery("raw", "processed", new LuceneClauseBuilder(), null);
            var   searchResult    = new SearchResult();

            searchMock.Setup(x => x.BuildQuery("foo", "", SearchQueryParserType.BestGuess, false)).Returns(searchQuery).AtMostOnce().Verifiable();
            searchMock.Setup(x => x.GetCachedQuery(searchQuery)).Returns((SearchResult)null).AtMostOnce().Verifiable();
            luceneMock
            .Verb("GET")
            .At("compact")
            .With("wikiid", "default")
            .With("q", searchQuery.LuceneQuery)
            .Returns(luceneXml)
            .ExpectCalls(DreamTimes.Once());
            searchMock.Setup(x => x.CacheQuery(It.IsAny <XDoc>(), searchQuery, It.Is <TrackingInfo>(t => t.PreviousQueryId == previousqueryid)))
            .Returns(searchResult)
            .AtMostOnce()
            .Verifiable();
            searchMock.Setup(x => x.FormatResultSet(
                                 searchResult,
                                 It.IsAny <SetDiscriminator>(),
                                 false,
                                 It.IsAny <TrackingInfo>(),
                                 It.IsAny <Result <XDoc> >())
                             )
            .Returns(new Result <XDoc>().WithReturn(responseXml))
            .AtMostOnce()
            .Verifiable();
            var response = _search
                           .With("q", "foo")
                           .With("previousqueryid", previousqueryid.ToString())
                           .With("since", since)
                           .With("before", before)
                           .With("limit", limit)
                           .With("offset", offset)
                           .Get(new Result <DreamMessage>()).Wait();

            Assert.IsTrue(response.IsSuccessful, response.ToErrorString());
            searchMock.VerifyAll();
            luceneMock.Verify();
            Assert.AreEqual(responseXml, response.ToDocument());
        }
コード例 #3
0
        public void Reindex_clears_search_cache()
        {
            var luceneMock = MockPlug.Setup(Utils.Settings.LuceneMockUri);

            luceneMock
            .Verb("DELETE")
            .At("clear")
            .With("wikiid", "default")
            .Returns(DreamMessage.Ok())
            .ExpectCalls(DreamTimes.Once());
            var mock = CreateMocks().Item1;

            mock.Setup(x => x.ClearCache()).AtMostOnce().Verifiable();
            var response = _deki.AtLocalHost.At("site", "search", "rebuild")
                           .With("apikey", Utils.Settings.ApiKey)
                           .Post(new Result <DreamMessage>()).Wait();

            Assert.IsTrue(response.IsSuccessful, response.ToErrorString());
            mock.VerifyAll();
            luceneMock.Verify();
            Assert.IsTrue(_indexRebuilderMock.WaitHandle.WaitOne(10.Seconds()), "index rebuilder wasn't triggered");
        }
コード例 #4
0
        public void InstanceKey_authtoken_gets_verified_against_deki()
        {
            var mockDeki            = new XUri("http://mock/deki");
            var dispatcherUri       = new XUri("http://mock/dispatcher");
            var authorizedRecipient = new XUri("http://mock/authorized");
            var dispatcher          = new DekiDispatcher(
                new DispatcherConfig {
                ServiceUri          = dispatcherUri,
                ServiceAccessCookie = new DreamCookie("service-key", "foo", dispatcherUri),
                ServiceConfig       = new XDoc("config").Elem("uri.deki", mockDeki).Elem("authtoken", "abc")
            },
                _mockRepository.Object
                );
            var sub = new XDoc("subscription-set")
                      .Elem("uri.owner", authorizedRecipient)
                      .Start("subscription")
                      .Attr("id", "1")
                      .Elem("channel", "event://default/deki/pages/*")
                      .Start("recipient").Attr("authtoken", "def").Elem("uri", authorizedRecipient).End()
                      .End();

            _log.DebugFormat("registering sub set");
            dispatcher.RegisterSet("abc", sub, "def");
            Assert.IsTrue(Wait.For(
                              () => dispatcher.CombinedSet.Subscriptions
                              .Where(s =>
                                     s.Channels.Where(c => c.ToString() == "event://default/deki/pages/*").Any() &&
                                     !s.Resources.Any()
                                     ).Any(),
                              10.Seconds()));
            MockPlug.Setup(mockDeki)
            .Verb("GET")
            .At("site", "settings")
            .With("apikey", "abc")
            .WithHeader("X-Deki-Site", "id=default")
            .Returns(new XDoc("config").Start("security").Elem("api-key", "def").End())
            .ExpectCalls(Times.Once());
            MockPlug.Setup(authorizedRecipient)
            .Verb("POST")
            .WithMessage(r => {
                if (!r.HasDocument)
                {
                    return(false);
                }
                var doc = r.ToDocument();
                _log.Debug(doc.ToPrettyString());
                return(doc["channel"].AsText == "event://default/deki/pages/update" &&
                       doc["pageid"].AsText == "10");
            })
            .ExpectCalls(Times.Once());
            var evDoc = new XDoc("deki-event")
                        .Attr("wikiid", "default")
                        .Elem("channel", "event://default/deki/pages/update")
                        .Elem("uri", "deki://default/pages/10")
                        .Elem("pageid", "10");
            var ev = new DispatcherEvent(evDoc, new XUri("event://default/deki/pages/update"), new XUri("deki://default/pages/10"), new XUri("http://default/deki/pages/10"));

            _log.DebugFormat("ready to dispatch event");
            dispatcher.Dispatch(ev);
            MockPlug.VerifyAll(TimeSpan.FromSeconds(10));
        }