public void Read_nonexistent_directory_returns_null()
{
MockPlug.Setup(AwsTestHelpers.AWS.S3Uri)
.Verb("GET")
.At(_config.Bucket)
.With("delimiter", "/")
.With("prefix", "root/path/foo/bar/")
.Returns(DreamMessage.Ok(new XDoc("ListBucketResult", "http://s3.amazonaws.com/doc/2006-03-01/")))
.ExpectAtLeastOneCall();
Assert.IsNull(_client.GetDataInfo("foo/bar/", false));
MockPlug.VerifyAll();
}
public void Cached_items_expire()
{
_cacheSeconds = 2;
MockPlug.Setup(new XUri("http://s3.amazonaws.com").At(BUCKET));
var attachment = CreateAttachmentForUpload();
var storage = Storage;
Assert.IsFalse(Directory.GetFiles(_tempDirectory).Any(), "there's already files in the temp dir");
storage.PutFile(attachment.Item1, SizeType.ORIGINAL, attachment.Item2);
Assert.AreEqual(1, Directory.GetFiles(_tempDirectory).Length, "Unexpected number of cache files after put");
Assert.IsTrue(Wait.For(() => !Directory.GetFiles(_tempDirectory).Any(), 120.Seconds()), "cache didn't empty in time");
}
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());
}
public void ImportManager_chains_reader_to_importer()
{
// Arrange
var dekiApiUri = new XUri("http://mock/@api/deki");
var importManifest = new XDoc("manifest");
var item1Uri = dekiApiUri.At("foo", "bar", "abc");
var item1Doc = new XDoc("item1");
var item2Uri = dekiApiUri.At("foo", "bar", "def");
var item2Doc = new XDoc("item2");
var importResponse = new XDoc("requests")
.Start("request")
.Attr("method", "POST")
.Attr("dataid", "abc")
.Attr("href", item1Uri)
.Start("header").Attr("name", "h_1").Attr("value", "v_1").End()
.Start("header").Attr("name", "h_2").Attr("value", "v_2").End()
.End()
.Start("request")
.Attr("method", "PUT")
.Attr("dataid", "def")
.Attr("href", item2Uri)
.End();
var mock = MockPlug.Register(dekiApiUri);
mock.Expect().Verb("POST").Uri(dekiApiUri.At("site", "import").With("relto", "0")).RequestDocument(importManifest).Response(DreamMessage.Ok(importResponse));
mock.Expect().Verb("POST").Uri(item1Uri).RequestHeader("h_1", "v_1").RequestHeader("h_2", "v_2").RequestDocument(item1Doc);
mock.Expect().Verb("PUT").Uri(item2Uri).RequestDocument(item2Doc);
var mockPackageReader = new Mock <IPackageReader>();
mockPackageReader.Setup(x => x.ReadManifest(It.IsAny <Result <XDoc> >())).Returns(importManifest.AsResult()).Verifiable("didn't get manifest");
var item1stream = new MemoryStream(item1Doc.ToBytes());
mockPackageReader.Setup(x => x.ReadData(It.Is <ImportItem>(y => y.DataId == "abc"), It.IsAny <Result <ImportItem> >()))
.Returns(() => new ImportItem("abc", importResponse["request[@dataid='abc']"], null, item1stream, item1stream.Length).AsResult())
.Verifiable();
var item2stream = new MemoryStream(item2Doc.ToBytes());
mockPackageReader.Setup(x => x.ReadData(It.Is <ImportItem>(y => y.DataId == "def"), It.IsAny <Result <ImportItem> >()))
.Returns(() => new ImportItem("def", importResponse["request[@dataid='def']"], null, item2stream, item2stream.Length).AsResult())
.Verifiable();
mockPackageReader.Setup(x => x.Dispose()).Verifiable();
// Act
var manager = ImportManager.CreateAsync(Plug.New(dekiApiUri), 0, mockPackageReader.Object, new Result <ImportManager>()).Wait();
manager.ImportAsync(new Result()).Wait();
//Assert
Assert.IsTrue(mock.WaitAndVerify(TimeSpan.FromSeconds(1)), mock.VerificationFailure);
mockPackageReader.VerifyAll();
}
public void Setup()
{
_inactiveLicense = Plug.New("resource://mindtouch.deki/MindTouch.Deki.Resources.license-inactive.xml").With(DreamOutParam.TYPE, MimeType.XML.ToString()).Get().ToDocument();
MockPlug.DeregisterAll();
_userMock = new Mock <IUserBL>();
_settingsMock = new Mock <IInstanceSettings>();
_licenseBLMock = new Mock <ILicenseBL>();
_seatingBLMock = new Mock <ISeatingBL>();
_userContext = new MockUserContext();
_wikiId = "bob";
_licenseController = new RemoteLicenseController(_wikiId, _storagePlug, GetRemoteLicense, LogUtils.CreateLog <RemoteLicenseController>());
}
public void Items_without_pageid_are_not_affected_by_filtering()
{
MockPlug.Setup(_authUri).Verb("POST").ExpectCalls(Times.Never());
var items = new[] {
Result(1, null),
Result(2, null),
};
var set = LuceneResultFilter.Filter(_authPlug, items, 0, int.MaxValue, new Result <IList <LuceneResult> >()).Wait();
Assert.AreEqual(2, set.Count);
Assert.AreEqual(items[0], set[0]);
MockPlug.VerifyAll(1.Seconds());
}
public void Can_call_WebHtml_on_uri()
{
var mock = MockPlug.Setup(new XUri("mock://mock"))
.Verb("GET")
.Returns(DreamMessage.Ok(MimeType.TEXT, "<strong>hi</strong>"))
.ExpectCalls(Times.Once());
DekiScriptTester.Default.Test(
"web.html(\"mock://mock\")",
"<html><body><strong>hi</strong></body></html>",
typeof(DekiScriptXml));
mock.Verify();
}
public void Can_put_file()
{
var data = AwsTestHelpers.CreateRandomDocument();
MockPlug.Setup(AwsTestHelpers.AWS.S3Uri)
.Verb("PUT")
.At(_config.RootedPath("foo", "bar"))
.WithBody(data)
.Returns(DreamMessage.Ok())
.ExpectAtLeastOneCall();
_client.PutFile("foo/bar", AwsTestHelpers.CreateFileHandle(data, null));
MockPlug.VerifyAll();
}
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());
}
public void Instance_limit_kicks_running_instance_in_favor_of_new()
{
using (var server = CreateTestServer()) {
var host = server.CreateMultiTenantService(300, 2);
var hostPlug = host.WithInternalKey().AtLocalHost;
var eventSubscriber = new XUri("mock://event/subscriber");
var subForAuthorized = new XDoc("subscription-set")
.Elem("uri.owner", eventSubscriber)
.Start("subscription")
.Attr("id", "1")
.Elem("channel", "event://a/deki/site/stop")
.Start("recipient")
.Attr("authtoken", Utils.Settings.ApiKey)
.Elem("uri", eventSubscriber)
.End()
.End();
_log.Debug("--- subscribing to instance shutdown event");
var result = hostPlug.At("pubsub", "subscribers").With("apikey", server.HostInfo.ApiKey).PostAsync(subForAuthorized).Wait();
Assert.IsTrue(result.IsSuccessful);
var resetEvent = new ManualResetEvent(false);
MockPlug.Register(eventSubscriber, (p, v, u, r, r2) => {
resetEvent.Set();
r2.Return(DreamMessage.Ok());
});
Assert.AreEqual(0, hostPlug.At("host").Get().ToDocument()["tenant"].ListLength);
_log.Debug("--- starting instance a");
Assert.IsTrue(hostPlug.At("site", "settings").WithHeader("X-Deki-Site", "id=a").Get().IsSuccessful);
_log.Debug("--- starting instance b");
Assert.IsTrue(hostPlug.At("site", "settings").WithHeader("X-Deki-Site", "id=b").Get().IsSuccessful);
_log.Debug("--- checking running instances");
var msg = hostPlug.At("host").Get(new Result <DreamMessage>()).Wait();
Assert.AreEqual(DreamStatus.Ok, msg.Status, "Failed to retrieve running instances");
var tenants = msg.ToDocument();
var tenant = tenants["tenant"];
Assert.AreEqual(2, tenant.ListLength, "Unexpected instance(s):\r\n" + tenants.ToPrettyString());
Assert.IsFalse(tenants["tenant[@wikiid='a']"].IsEmpty, "couldn't find instance 'a'");
Assert.IsFalse(tenants["tenant[@wikiid='b']"].IsEmpty, "couldn't find instance 'b'");
_log.Debug("--- starting instance c");
msg = hostPlug.At("site", "settings").WithHeader("X-Deki-Site", "id=c").Get(new Result <DreamMessage>()).Wait();
Assert.IsTrue(msg.IsSuccessful, msg.ToErrorString());
_log.Debug("--- waiting for some instance to shut down");
Assert.IsTrue(resetEvent.WaitOne(10.Seconds()), "no instance was shut down");
msg = hostPlug.At("host").Get(new Result <DreamMessage>()).Wait();
Assert.AreEqual(DreamStatus.Ok, msg.Status, "Failed to retrieve running instances");
tenants = msg.ToDocument();
tenant = tenants["tenant"];
Assert.AreEqual(2, tenant.ListLength, "Unexpected instance(s):\r\n" + tenants.ToPrettyString());
Assert.IsFalse(tenants["tenant[@wikiid='c']"].IsEmpty, "couldn't find instance 'c'");
}
}
public void Setup()
{
_config = new AwsS3ClientConfig {
Endpoint = AwsTestHelpers.AWS,
Bucket = "bucket",
Delimiter = "/",
RootPath = "root/path",
PrivateKey = "private",
PublicKey = "public",
Timeout = TimeSpan.FromSeconds(30)
};
_client = new AwsS3Client(_config, TaskTimerFactory.Current);
MockPlug.DeregisterAll();
}
public void Can_init_and_read_file()
{
var data = Helper.CreateRandomDocument();
MockPlug.Setup(Helper.AWS)
.Verb("GET")
.At(_config.RootedPath("foo", "bar"))
.Returns(DreamMessage.Ok(data))
.ExpectAtLeastOneCall();
var response = _storage.AtLocalHost.At("foo", "bar").Get(new Result <DreamMessage>()).Wait();
Assert.IsTrue(response.IsSuccessful);
Assert.AreEqual(data.ToCompactString(), response.ToDocument().ToCompactString());
}
public void Teardown()
{
MockPlug.DeregisterAll();
if (!string.IsNullOrEmpty(_tempFilename))
{
_filestream.Dispose();
File.Delete(_tempFilename);
}
if (_s3Storage != null)
{
_s3Storage.Dispose();
}
_s3Storage = null;
}
public void Can_update_license_seat_licensing()
{
// Arrange
var currentLicense = new XDoc("current");
var newLicense = new XDoc("new");
var newExpiration = DateTime.UtcNow.AddDays(1);
var newPermissions = Permissions.BROWSE;
ulong?newOwnerId = 1;
var currentLicenseData = new LicenseData()
.WithLicenseDocument(currentLicense)
.WithState(LicenseStateType.COMMERCIAL)
.WithExpiration(DateTime.UtcNow)
.WithPermissions(Permissions.NONE)
.WithSiteOwnerUserId(1)
.Checked(DateTime.UtcNow);
var newLicenseData = new LicenseData().WithLicenseDocument(newLicense)
.WithState(LicenseStateType.COMMERCIAL)
.WithExpiration(newExpiration)
.WithPermissions(newPermissions)
.WithSiteOwnerUserId(newOwnerId)
.Checked(DateTime.UtcNow);
var tempLicenseNewLicenseData = new LicenseData().WithLicenseDocument(newLicense);
_licenseBLMock.Setup(x => x.BuildLicenseData(newLicense, true, true)).Returns(tempLicenseNewLicenseData).Verifiable();
_licenseBLMock.Setup(x => x.ValidateNewLicenseTransition(It.Is <LicenseData>(l => l.AreSame(tempLicenseNewLicenseData)), It.Is <LicenseData>(l => l.AreSame(currentLicenseData))))
.Returns(newLicenseData)
.Verifiable();
_seatingBLMock.Setup(x => x.IsSeatLicensingEnabled(currentLicenseData)).Returns(true);
_seatingBLMock.Setup(x => x.IsSeatLicensingEnabled(newLicense)).Returns(true);
_seatingBLMock.Setup(x => x.HandleSeatTransition(newLicense)).Returns(new SeatAssignmentInfo(2, 5));
MockPlug.Setup(_storagePlug).At(_wikiId, "license.xml").Verb("Put").WithBody(newLicense).ExpectAtLeastOneCall();
// Act
var updatedLicense = _licenseController.UpdateLicense(newLicense, currentLicenseData, _licenseBLMock.Object, _seatingBLMock.Object);
// Assert
MockPlug.VerifyAll();
_licenseBLMock.Verify(x => x.Validate(newLicense), Times.Once());
_licenseBLMock.Verify(x => x.ValidateNewLicenseTransition(It.Is <LicenseData>(l => l.AreSame(tempLicenseNewLicenseData)), It.Is <LicenseData>(l => l.AreSame(currentLicenseData))), Times.Once());
_seatingBLMock.Verify(x => x.IsSeatLicensingEnabled(currentLicenseData), Times.Once());
_seatingBLMock.Verify(x => x.IsSeatLicensingEnabled(newLicense), Times.Once());
_seatingBLMock.Verify(x => x.ValidateLicenseUpdateUser(newLicense), Times.Once());
_seatingBLMock.Verify(x => x.HandleSeatTransition(newLicense), Times.Once());
_seatingBLMock.Verify(x => x.SetOwnerUserSeat(newLicenseData), Times.Once());
Assert.AreSame(newLicenseData, updatedLicense);
Assert.AreEqual(newLicense, newLicenseData.LicenseDoc);
Assert.AreEqual(newExpiration, newLicenseData.LicenseExpiration);
Assert.AreEqual(newOwnerId, newLicenseData.SiteOwnerUserId);
Assert.AreEqual(newPermissions, newLicenseData.AnonymousPermissions);
}
public void Can_apply_limit()
{
MockPlug.Setup(_authUri)
.Verb("POST")
.Returns(DreamMessage.Ok(MimeType.TEXT, ""));
var items = new[] {
Result(1),
Result(2),
};
var set = LuceneResultFilter.Filter(_authPlug, items, 0, 1, new Result <IList <LuceneResult> >()).Wait();
Assert.AreEqual(1, set.Count);
Assert.AreEqual(items[0], set[0]);
}
public void Can_get_file()
{
var attachment = CreateAttachmentForDownload();
var s3Filename = GetS3Filename(attachment);
MockPlug.Setup(new XUri("http://s3.amazonaws.com").At(BUCKET))
.Verb("GET")
.At(s3Filename)
.Returns(DreamMessage.Ok(MimeType.TEXT, "foobar"))
.ExpectCalls(Times.Once());
var info = Storage.GetFile(attachment, SizeType.ORIGINAL, false);
Assert.AreEqual("foobar", Encoding.ASCII.GetString(info.Stream.ReadBytes(info.Length)));
MockPlug.VerifyAll(1.Seconds());
}
public void Exporter_can_retrieve_items_by_dataid()
{
// Arrange
XUri dekiApiUri = new XUri("http://mock/@api/deki");
XDoc exportDocument = new XDoc("export");
XUri item1Uri = dekiApiUri.At("foo", "bar", "abc");
XDoc item1Doc = new XDoc("item1");
XUri item2Uri = dekiApiUri.At("foo", "bar", "def");
XDoc item2Doc = new XDoc("item2");
XDoc exportResponse = new XDoc("export")
.Start("requests")
.Start("request")
.Attr("method", "GET")
.Attr("dataid", "abc")
.Attr("href", item1Uri)
.Start("header").Attr("name", "h_1").Attr("value", "v_1").End()
.Start("header").Attr("name", "h_2").Attr("value", "v_2").End()
.End()
.Start("request")
.Attr("method", "GET")
.Attr("dataid", "def")
.Attr("href", item2Uri)
.End()
.End()
.Start("manifest")
.Start("foo").Attr("dataid", "abc").End()
.Start("bar").Attr("dataid", "def").End()
.End();
AutoMockPlug mock = MockPlug.Register(dekiApiUri);
mock.Expect().Verb("POST").Uri(dekiApiUri.At("site", "export").With("relto", "0")).RequestDocument(exportDocument).Response(DreamMessage.Ok(exportResponse));
mock.Expect().Verb("GET").Uri(item1Uri).RequestHeader("h_1", "v_1").RequestHeader("h_2", "v_2").Response(DreamMessage.Ok(item1Doc));
mock.Expect().Verb("GET").Uri(item2Uri).Response(DreamMessage.Ok(item2Doc));
// Act
Exporter exporter = Exporter.CreateAsync(Plug.New(dekiApiUri), exportDocument, 0, new Result <Exporter>()).Wait();
ExportItem item1 = exporter.GetItemAsync("abc", new Result <ExportItem>()).Wait();
ExportItem item2 = exporter.GetItemAsync("def", new Result <ExportItem>()).Wait();
//Assert
Assert.IsTrue(mock.WaitAndVerify(TimeSpan.FromSeconds(1)));
Assert.AreEqual(exportResponse["manifest"], exporter.Manifest);
Assert.AreEqual(new string[] { "abc", "def" }, exporter.DataIds);
Assert.AreEqual(exporter.Manifest["*[@dataid='abc']"], item1.ItemManifest);
Assert.AreEqual(exporter.Manifest["*[@dataid='def']"], item2.ItemManifest);
Assert.AreEqual(item1Doc, XDocFactory.From(new StreamReader(item1.Data), MimeType.TEXT_XML));
Assert.AreEqual(item2Doc, XDocFactory.From(new StreamReader(item2.Data), MimeType.TEXT_XML));
}
public void Send_cache_control_header_when_writing_object()
{
var data = AwsTestHelpers.CreateRandomDocument();
MockPlug.Setup(AwsTestHelpers.AWS.S3Uri)
.Verb("PUT")
.At(_config.RootedPath("foo", "bar"))
.WithHeader("Cache-Control", "max-age=29030400, public")
.WithBody(data)
.Returns(DreamMessage.Ok())
.ExpectAtLeastOneCall();
var handle = AwsTestHelpers.CreateFileHandle(data, null);
handle.CacheControl = "max-age=29030400, public";
_client.PutFile("foo/bar", handle);
}
public void Limit_smaller_than_item_set_forces_authorization_in_chunks_as_candidates_nears_limit()
{
var items = new List <LuceneResult>();
for (var i = 1; i <= 200; i++)
{
items.Add(Result(i));
}
// first chunk should ask for 50 ids and we'll filter 20 from that set
MockPlug.Setup(_authUri)
.Verb("POST")
.WithMessage(m => {
var t = m.ToText();
var match = t.EqualsInvariant(items.Select(x => x.PageId.Value).Take(50).ToCommaDelimitedString());
_log.DebugFormat("first chunk match? {0} => {1}", match, t);
return(match);
})
.Returns(DreamMessage.Ok(MimeType.TEXT, S(10, 39).ToCommaDelimitedString()))
.ExpectCalls(Times.Once());
// second chunk should ask for 30 and we'll filter 5 from that set
// which gives it a total larger than our limit, i.e. it won't try for a third chunk
MockPlug.Setup(_authUri)
.Verb("POST")
.WithMessage(m => {
var t = m.ToText();
var match = t.EqualsInvariant(items.Select(x => x.PageId.Value).Skip(50).Take(30).ToCommaDelimitedString());
_log.DebugFormat("second chunk match? {0} => {1}", match, t);
return(match);
})
.Returns(DreamMessage.Ok(MimeType.TEXT, S(51, 55).ToCommaDelimitedString()))
.ExpectCalls(Times.Once());
var builder = new LuceneResultFilter(_authPlug, 10000, 20);
var set = Coroutine.Invoke(builder.Filter, items, 0, 30, new Result <IList <LuceneResult> >()).Wait();
Assert.AreEqual(30, set.Count);
// we expect a sequence of 1-9,40-50,56-... and take the first 30
var expected = S(1, 9).Union(S(40, 50)).Union(S(56, 100)).Take(30);
Assert.AreEqual(
expected.ToCommaDelimitedString(),
set.Select(x => x.PageId.Value).ToCommaDelimitedString()
);
MockPlug.VerifyAll(1.Seconds());
}
public void Read_file_with_lazy_expiration_returns_null()
{
var data = AwsTestHelpers.CreateRandomDocument();
MockPlug.Setup(AwsTestHelpers.AWS.S3Uri)
.Verb("GET")
.At(_config.RootedPath("foo", "bar"))
.Returns(invocation => {
var msg = DreamMessage.Ok(data);
msg.Headers["x-amz-meta-expire"] = DateTime.UtcNow.Subtract(10.Minutes()).ToEpoch().ToInvariantString();
msg.Headers["x-amz-meta-ttl"] = "10";
return(msg);
})
.ExpectAtLeastOneCall();
Assert.IsNull(_client.GetDataInfo("foo/bar", false));
MockPlug.VerifyAll();
}
public void Importer_Items_are_populated_with_request_and_manifest_docs()
{
// Arrange
var dekiApiUri = new XUri("http://mock/@api/deki");
var importManifest = new XDoc("manifest")
.Start("item").Attr("dataid", "abc").Elem("foo", "bar").End()
.Start("item").Attr("dataid", "def").Elem("baz", "flip").End();
var item1Uri = dekiApiUri.At("foo", "bar", "abc");
var item2Uri = dekiApiUri.At("foo", "bar", "def");
var importResponse = new XDoc("requests")
.Start("request")
.Attr("method", "POST")
.Attr("dataid", "abc")
.Attr("href", item1Uri)
.Start("header").Attr("name", "h_1").Attr("value", "v_1").End()
.Start("header").Attr("name", "h_2").Attr("value", "v_2").End()
.End()
.Start("request")
.Attr("method", "PUT")
.Attr("dataid", "def")
.Attr("href", item2Uri)
.End();
var mock = MockPlug.Register(dekiApiUri);
mock.Expect().Verb("POST").Uri(dekiApiUri.At("site", "import").With("relto", "0")).RequestDocument(importManifest).Response(DreamMessage.Ok(importResponse));
// Act
var importer = Importer.CreateAsync(Plug.New(dekiApiUri), importManifest, 0, new Result <Importer>()).Wait();
//Assert
Assert.IsTrue(mock.WaitAndVerify(TimeSpan.FromSeconds(1)));
var item1 = importer.Items.Where(x => x.DataId == "abc").FirstOrDefault();
Assert.IsNotNull(item1);
Assert.IsNotNull(item1.Manifest);
Assert.AreEqual(importManifest[".//*[@dataid='abc']"], item1.Manifest);
Assert.IsNotNull(item1.Request);
Assert.AreEqual(importResponse[".//*[@dataid='abc']"], item1.Request);
var item2 = importer.Items.Where(x => x.DataId == "def").FirstOrDefault();
Assert.IsNotNull(item2);
Assert.IsNotNull(item2.Manifest);
Assert.AreEqual(importManifest[".//*[@dataid='def']"], item2.Manifest);
Assert.IsNotNull(item1.Request);
Assert.AreEqual(importResponse[".//*[@dataid='def']"], item2.Request);
}
public void GetOpensearch()
{
// GET:site/opensearch
// ...
var p = Utils.BuildPlugForAdmin();
var mock = MockPlug.Setup(Utils.Settings.LuceneMockUri)
.Verb("GET")
.At(new[] { "compact" })
.With("wikiid", "default")
.With("q", "+(title:\"GetOpensearch\"^2) +type:(wiki document image comment binary)")
.Returns(DreamMessage.Ok(new XDoc("documents")))
.ExpectCalls(Times.Once());
var msg = p.At("site", "opensearch").With("q", string.Format("title:\"GetOpensearch\"^2")).With("format", "xml").Get(new Result <DreamMessage>()).Wait();
Assert.IsTrue(msg.IsSuccessful);
mock.Verify();
}
public void Can_put_file_with_expiration()
{
var data = AwsTestHelpers.CreateRandomDocument();
MockPlug.Setup(AwsTestHelpers.AWS.S3Uri)
.Verb("PUT")
.At(_config.RootedPath("foo", "bar"))
.WithHeader("x-amz-meta-ttl", 1.ToInvariantString())
.WithBody(data)
.Returns(DreamMessage.Ok())
.ExpectAtLeastOneCall();
MockPlug.Setup(AwsTestHelpers.AWS.S3Uri)
.Verb("DELETE")
.At(_config.RootedPath("foo", "bar"))
.Returns(new DreamMessage(DreamStatus.NoContent, null))
.ExpectAtLeastOneCall();
_client.PutFile("foo/bar", AwsTestHelpers.CreateFileHandle(data, 1.Seconds()));
MockPlug.VerifyAll(10.Seconds());
}
public void Instance_is_accessible_on_receiving_transition_push_via_update_license()
{
var eventSubscriber = new XUri("mock://event/subscriber");
var subForAuthorized = new XDoc("subscription-set")
.Elem("uri.owner", eventSubscriber)
.Start("subscription")
.Attr("id", "1")
.Elem("channel", "event://default/deki/site/license/update")
.Start("recipient")
.Attr("authtoken", Utils.Settings.ApiKey)
.Elem("uri", eventSubscriber)
.End()
.End();
var result = Utils.Settings.Server.At("pubsub", "subscribers").With("apikey", Utils.Settings.ApiKey).PostAsync(subForAuthorized).Wait();
Assert.IsTrue(result.IsSuccessful);
var mre = new ManualResetEvent(false);
DreamMessage settingsResult = null;
MockPlug.Register(eventSubscriber, (p, v, u, r, r2) => {
r2.Return(DreamMessage.Ok());
_log.DebugFormat("got transition event, trying to fetch license");
settingsResult = Utils.Settings.Server.At("license")
.With("apikey", Utils.Settings.ApiKey)
.WithHeader("X-Deki-Site", "id=default")
.Get(new Result <DreamMessage>()).Wait();
mre.Set();
});
var licenses = new XDoc("licenses")
.Start("old-license").Add(LicenseUtil.InactiveLicense).End()
.Start("new-license").Add(LicenseUtil.TestLicense);
var response = Utils.Settings.Server.At("license")
.With("apikey", Utils.Settings.ApiKey)
.Put(licenses, new Result <DreamMessage>())
.Wait();
Assert.AreEqual(DreamStatus.Ok, response.Status, "unable to update license");
Assert.IsTrue(mre.WaitOne(10.Seconds()));
Assert.IsTrue(settingsResult.IsSuccessful);
var settings = settingsResult.ToDocument();
Assert.AreEqual("commercial", settings["@type"].AsText.ToLower());
}
public void Cache_hit_and_expire()
{
Plug deki = Plug.New("http://mock/deki");
AutoMockPlug autoMock = MockPlug.Register(deki.Uri);
Action expire = null;
PageChangeCache cache = new PageChangeCache(deki, (key, trigger) => expire = trigger);
DateTime timestamp = DateTime.UtcNow;
XUri pageUri = deki.Uri.At("pages", "10").With("redirects", "0");
XDoc pageResponse = new XDoc("page")
.Elem("uri.ui", "http://foo.com/@api/deki/pages/10")
.Elem("title", "foo")
.Elem("path", "foo/bar");
XUri feedUri = deki.Uri
.At("pages", "10", "feed")
.With("redirects", "0")
.With("format", "raw")
.With("since", timestamp.Subtract(TimeSpan.FromSeconds(10)).ToString("yyyyMMddHHmmss"));
XDoc changeResponse = new XDoc("table")
.Start("change")
.Elem("rc_summary", "Two edits")
.Elem("rc_comment", "edit 1")
.Elem("rc_comment", "edit 2")
.End();
_log.Debug("first get");
autoMock.Expect("GET", pageUri, (XDoc)null, DreamMessage.Ok(pageResponse));
autoMock.Expect("GET", feedUri, (XDoc)null, DreamMessage.Ok(changeResponse));
Assert.IsNotNull(Coroutine.Invoke(cache.GetPageData, (uint)10, "foo", timestamp, CultureInfo.InvariantCulture, (string)null, new Result <PageChangeData>()).Wait());
Assert.IsTrue(autoMock.WaitAndVerify(10.Seconds()));
_log.Debug("second get, cache hit");
autoMock.Reset();
Assert.IsNotNull(Coroutine.Invoke(cache.GetPageData, (uint)10, "foo", timestamp, CultureInfo.InvariantCulture, (string)null, new Result <PageChangeData>()).Wait());
Assert.IsTrue(autoMock.WaitAndVerify(2.Seconds()));
_log.Debug("third get, cache miss");
autoMock.Reset();
autoMock.Expect("GET", pageUri, (XDoc)null, DreamMessage.Ok(pageResponse));
autoMock.Expect("GET", feedUri, (XDoc)null, DreamMessage.Ok(changeResponse));
expire();
Assert.IsNotNull(Coroutine.Invoke(cache.GetPageData, (uint)10, "foo", timestamp, CultureInfo.InvariantCulture, (string)null, new Result <PageChangeData>()).Wait());
Assert.IsTrue(autoMock.WaitAndVerify(10.Seconds()));
}
public void Items_are_filtered_by_pageId()
{
MockPlug.Setup(_authUri)
.Verb("POST")
.WithMessage(m => {
var t = m.ToText();
return(t.EqualsInvariant("1,2"));
})
.Returns(DreamMessage.Ok(MimeType.TEXT, "1"))
.ExpectCalls(Times.Once());
var items = new[] {
Result(1),
Result(2),
};
var set = LuceneResultFilter.Filter(_authPlug, items, 0, int.MaxValue, new Result <IList <LuceneResult> >()).Wait();
Assert.AreEqual(1, set.Count);
Assert.AreEqual(items[1], set[0]);
MockPlug.VerifyAll(1.Seconds());
}
public void Can_read_file()
{
var data = AwsTestHelpers.CreateRandomDocument();
MockPlug.Setup(AwsTestHelpers.AWS.S3Uri)
.Verb("GET")
.At(_config.RootedPath("foo", "bar"))
.Returns(DreamMessage.Ok(data))
.ExpectAtLeastOneCall();
var response = _client.GetDataInfo("foo/bar", false);
MockPlug.VerifyAll();
Assert.IsFalse(response.IsDirectory);
var fileinfo = response.AsFileHandle();
Assert.AreEqual(MimeType.XML.ToString(), fileinfo.MimeType.ToString());
var data2 = XDocFactory.From(fileinfo.Stream, fileinfo.MimeType);
Assert.AreEqual(data, data2);
}
public void GetOpensearchSuggestions()
{
// GET:site/opensearch/suggestions
// ...
var p = Utils.BuildPlugForAdmin();
var mock = MockPlug.Setup(Utils.Settings.LuceneMockUri)
.Verb("GET")
.With("wikiid", "default")
.With("q", "+(title:/foo/bar ) +type:(wiki document image comment binary) -namespace:\"template_talk\" -namespace:\"help\" -namespace:\"help_talk\"")
.With("max", "100")
.With("offset", "0")
.With("sortBy", "-score")
.Returns(DreamMessage.Ok(new XDoc("documents")))
.ExpectCalls(Times.Once());
var msg = p.At("site", "opensearch", "suggestions").With("q", "/foo/bar").Get(new Result <DreamMessage>()).Wait();
Assert.IsTrue(msg.IsSuccessful);
mock.Verify();
}
public void Instance_expires()
{
using (var server = CreateTestServer()) {
_log.Debug("--- creating multitenant service");
var host = server.CreateMultiTenantService(5, 10);
var p = host.WithInternalKey().AtLocalHost;
var eventSubscriber = new XUri("mock://event/subscriber");
var subForAuthorized = new XDoc("subscription-set")
.Elem("uri.owner", eventSubscriber)
.Start("subscription")
.Attr("id", "1")
.Elem("channel", "event://a/deki/site/stop")
.Start("recipient")
.Attr("authtoken", Utils.Settings.ApiKey)
.Elem("uri", eventSubscriber)
.End()
.End();
_log.Debug("--- subscribing to instance shutdown event");
var result = p.At("pubsub", "subscribers").With("apikey", server.HostInfo.ApiKey).PostAsync(subForAuthorized).Wait();
Assert.IsTrue(result.IsSuccessful);
MockPlug.Setup(eventSubscriber).Verb("POST").ExpectCalls(Times.Once());
Assert.AreEqual(0, p.At("host").Get().ToDocument()["tenant"].ListLength);
_log.Debug("--- gettings settings/forcing site init");
Assert.IsTrue(p.At("site", "settings").WithHeader("X-Deki-Site", "id=a").Get().IsSuccessful);
var msg = p.At("host").Get(new Result <DreamMessage>()).Wait();
Assert.AreEqual(DreamStatus.Ok, msg.Status, "Failed to retrieve running instances");
var tenants = msg.ToDocument();
var tenant = tenants["tenant"];
Assert.AreEqual(1, tenant.ListLength, "Unexpected instance(s):\r\n" + tenants.ToPrettyString());
Assert.AreEqual("a", tenant["@wikiid"].AsText ?? String.Empty, "Unexpected wiki id");
var status = tenant["@status"].AsText ?? "";
Assert.Contains(status, new[] { "running", "starting_services" }, "Unexpected status: " + status);
_log.Debug("---- wait for expire");
MockPlug.VerifyAll(30.Seconds());
Assert.IsTrue(
p.At("host").Get(new Result <DreamMessage>()).Wait().ToDocument()["tenant[@wikiid='a']"].IsEmpty,
"instance didn't time out"
);
_log.Debug("----- instance has shut down");
}
}
public void Importer_hits_import_feature_with_reltopath()
{
// Arrange
XUri dekiApiUri = new XUri("http://mock/@api/deki");
XDoc importManifest = new XDoc("manifest");
XDoc importResponse = new XDoc("requests")
.Start("request").Attr("dataid", "a").End()
.Start("request").Attr("dataid", "b").End()
.Start("request").Attr("dataid", "c").End();
AutoMockPlug mock = MockPlug.Register(dekiApiUri);
mock.Expect("POST", dekiApiUri.At("site", "import").With("reltopath", "/foo/bar"), importManifest, DreamMessage.Ok(importResponse));
// Act
Importer importer = Importer.CreateAsync(Plug.New(dekiApiUri), importManifest, "/foo/bar", new Result <Importer>()).Wait();
//Assert
Assert.IsTrue(mock.WaitAndVerify(TimeSpan.FromSeconds(1)));
Assert.AreEqual(importManifest, importer.Manifest);
Assert.AreEqual(new[] { "a", "b", "c" }, importer.Items.Select(x => x.DataId).ToArray());
}
public void Register(XUri uri, MockPlug.MockInvokeDelegate invokeDelegate)
{
lock(_registry) {
if(_registry.ContainsKey(uri)) {
throw new ArgumentException("the uri already has a mock registered");
}
_registry.Add(uri, invokeDelegate);
_map.Add(uri, uri);
}
}
public void Register(MockPlug.IMockInvokee invokee)
{
lock(_registry) {
if(_registry.ContainsKey(invokee.Uri)) {
throw new ArgumentException("the uri already has a mock registered");
}
_registry.Add(invokee.Uri, invokee);
_map.Add(invokee.Uri, invokee);
}
}
