public async Task soft_deleted_stream_when_recreated_preserves_metadata_except_truncatebefore()
{
const string stream = "soft_deleted_stream_when_recreated_preserves_metadata_except_truncatebefore";
Assert.AreEqual(1,
(await _conn.AppendToStreamAsync(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(),
TestEvent.NewTestEvent())).NextExpectedVersion);
Assert.AreEqual(0, (await _conn.SetStreamMetadataAsync(stream, ExpectedVersion.NoStream,
StreamMetadata.Build().SetTruncateBefore(long.MaxValue)
.SetMaxCount(100)
.SetDeleteRole("some-role")
.SetCustomProperty("key1", true)
.SetCustomProperty("key2", 17)
.SetCustomProperty("key3", "some value"))).NextExpectedVersion);
var events = new[] { TestEvent.NewTestEvent(), TestEvent.NewTestEvent(), TestEvent.NewTestEvent() };
Assert.AreEqual(4, (await _conn.AppendToStreamAsync(stream, 1, events)).NextExpectedVersion);
await Task.Delay(50); //TODO: This is a workaround until github issue #1744 is fixed
var res = await _conn.ReadStreamEventsForwardAsync(stream, 0, 100, false);
Assert.AreEqual(SliceReadStatus.Success, res.Status);
Assert.AreEqual(4, res.LastEventNumber);
Assert.AreEqual(3, res.Events.Length);
Assert.AreEqual(events.Select(x => x.EventId), res.Events.Select(x => x.OriginalEvent.EventId));
Assert.AreEqual(new[] { 2, 3, 4 }, res.Events.Select(x => x.OriginalEvent.EventNumber));
var meta = await _conn.GetStreamMetadataAsync(stream);
Assert.AreEqual(1, meta.MetastreamVersion);
Assert.AreEqual(2, meta.StreamMetadata.TruncateBefore);
Assert.AreEqual(100, meta.StreamMetadata.MaxCount);
Assert.AreEqual("some-role", meta.StreamMetadata.Acl.DeleteRole);
Assert.AreEqual(true, meta.StreamMetadata.GetValue <bool>("key1"));
Assert.AreEqual(17, meta.StreamMetadata.GetValue <int>("key2"));
Assert.AreEqual("some value", meta.StreamMetadata.GetValue <string>("key3"));
}
public async Task returns_expected_result(long expectedVersion, string displayName, bool useSsl,
bool createStream, StreamMetadataBuilder builder)
{
var isEmpty = builder == null;
var streamName = $"{GetStreamName()}_{displayName}_{useSsl}_{createStream}_{isEmpty}";
var connection = _fixture.Connections[useSsl];
if (createStream)
{
await connection.AppendToStreamAsync(streamName, ExpectedVersion.NoStream, _fixture.CreateTestEvents())
.WithTimeout();
}
var expected = (builder ?? StreamMetadata.Build()).Build();
await connection.SetStreamMetadataAsync(streamName, expectedVersion, expected).WithTimeout();
var result = await connection.GetStreamMetadataAsync(streamName).WithTimeout();
var actual = result.StreamMetadata;
Assert.Equal(streamName, result.Stream);
Assert.False(result.IsStreamDeleted);
Assert.Equal(0, result.MetastreamVersion);
Assert.Equal(expected.MaxCount, actual.MaxCount);
Assert.Equal(expected.MaxAge, actual.MaxAge);
Assert.Equal(expected.TruncateBefore, actual.TruncateBefore);
Assert.Equal(expected.CacheControl, actual.CacheControl);
Assert.Equal(expected.Acl?.ReadRoles, actual.Acl?.ReadRoles);
Assert.Equal(expected.Acl?.WriteRoles, actual.Acl?.WriteRoles);
Assert.Equal(expected.Acl?.DeleteRoles, actual.Acl?.DeleteRoles);
Assert.Equal(expected.Acl?.MetaReadRoles, actual.Acl?.MetaReadRoles);
Assert.Equal(expected.Acl?.MetaWriteRoles, actual.Acl?.MetaWriteRoles);
Assert.Equal(expected.CustomKeys.Count(), actual.CustomKeys.Count());
foreach (var key in actual.CustomKeys)
{
Assert.True(expected.TryGetValueAsRawJsonString(key, out var value));
Assert.Equal(actual.GetValueAsRawJsonString(key), value);
}
}
protected async Task SecureStream()
{
var metadata =
(StreamMetadata)
StreamMetadata.Build()
.SetMetadataReadRole("admin")
.SetMetadataWriteRole("admin")
.SetReadRole("admin")
.SetWriteRole("admin");
var jsonMetadata = metadata.AsJsonString();
var response = await MakeArrayEventsPost(
TestMetadataStream,
new[] {
new {
EventId = Guid.NewGuid(),
EventType = SystemEventTypes.StreamMetadata,
Data = new JRaw(jsonMetadata)
}
});
Assert.AreEqual(HttpStatusCode.Created, response.StatusCode);
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
var settings = new SystemSettings(userStreamAcl: new StreamAcl(null, "user1", null, null, null),
systemStreamAcl: new StreamAcl(null, "user1", null, null, null));
Connection.SetSystemSettingsAsync(settings, new UserCredentials("adm", "admpa$$")).Wait();
Connection.SetStreamMetadataAsync("user-no-acl", ExpectedVersion.NoStream,
StreamMetadata.Build(), new UserCredentials("adm", "admpa$$")).Wait();
Connection.SetStreamMetadataAsync("user-w-diff", ExpectedVersion.NoStream,
StreamMetadata.Build().SetWriteRole("user2"), new UserCredentials("adm", "admpa$$")).Wait();
Connection.SetStreamMetadataAsync("user-w-multiple", ExpectedVersion.NoStream,
StreamMetadata.Build().SetWriteRoles(new[] { "user1", "user2" }),
new UserCredentials("adm", "admpa$$"))
.Wait();
Connection.SetStreamMetadataAsync("user-w-restricted", ExpectedVersion.NoStream,
StreamMetadata.Build().SetWriteRoles(new string[0]), new UserCredentials("adm", "admpa$$")).Wait();
Connection.SetStreamMetadataAsync("user-w-all", ExpectedVersion.NoStream,
StreamMetadata.Build().SetWriteRole(SystemRoles.All), new UserCredentials("adm", "admpa$$")).Wait();
Connection.SetStreamMetadataAsync("user-r-restricted", ExpectedVersion.NoStream,
StreamMetadata.Build().SetReadRole("user1"), new UserCredentials("adm", "admpa$$")).Wait();
Connection.SetStreamMetadataAsync("$sys-no-acl", ExpectedVersion.NoStream,
StreamMetadata.Build(), new UserCredentials("adm", "admpa$$")).Wait();
Connection.SetStreamMetadataAsync("$sys-w-diff", ExpectedVersion.NoStream,
StreamMetadata.Build().SetWriteRole("user2"), new UserCredentials("adm", "admpa$$")).Wait();
Connection.SetStreamMetadataAsync("$sys-w-multiple", ExpectedVersion.NoStream,
StreamMetadata.Build().SetWriteRoles(new[] { "user1", "user2" }),
new UserCredentials("adm", "admpa$$"))
.Wait();
Connection.SetStreamMetadataAsync("$sys-w-restricted", ExpectedVersion.NoStream,
StreamMetadata.Build().SetWriteRoles(new string[0]), new UserCredentials("adm", "admpa$$")).Wait();
Connection.SetStreamMetadataAsync("$sys-w-all", ExpectedVersion.NoStream,
StreamMetadata.Build().SetWriteRole(SystemRoles.All), new UserCredentials("adm", "admpa$$")).Wait();
}
public override async Task SetUp()
{
await base.SetUp();
_node = new MiniNode <TLogFormat, TStreamId>(PathName);
await _node.Start();
_conn = BuildConnection(_node);
await _conn.ConnectAsync();
_conn.SetStreamMetadataAsync(SystemStreams.AllStream, -1,
StreamMetadata.Build().SetReadRole(SystemRoles.All),
new UserCredentials(SystemUsers.Admin, SystemUsers.DefaultAdminPassword)).Wait();
_testEvents = Enumerable
.Range(0, 10)
.Select(x => TestEvent.NewTestEvent(x.ToString(), eventName: "AEvent"))
.ToList();
_testEvents.AddRange(
Enumerable
.Range(0, 10)
.Select(x => TestEvent.NewTestEvent(x.ToString(), eventName: "BEvent")).ToList());
_testEventsAfter = Enumerable
.Range(0, 10)
.Select(x => TestEvent.NewTestEvent(x.ToString(), eventName: "AEvent"))
.ToList();
_testEventsAfter.AddRange(
Enumerable
.Range(0, 10)
.Select(x => TestEvent.NewTestEvent(x.ToString(), eventName: "BEvent")).ToList());
await _conn.AppendToStreamAsync("stream-a", ExpectedVersion.NoStream, _testEvents.EvenEvents());
await _conn.AppendToStreamAsync("stream-b", ExpectedVersion.NoStream, _testEvents.OddEvents());
}
public void less_strict_max_count_doesnt_change_anything_for_stream_forward_read()
{
const string stream = "less_strict_max_count_doesnt_change_anything_for_stream_forward_read";
_conn.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, _testEvents).Wait();
_conn.SetStreamMetadataAsync(stream, ExpectedVersion.EmptyStream, StreamMetadata.Build().SetTruncateBefore(2)).Wait();
var res = _conn.ReadStreamEventsForwardAsync(stream, 0, 100, false).Result;
Assert.AreEqual(SliceReadStatus.Success, res.Status);
Assert.AreEqual(3, res.Events.Length);
Assert.AreEqual(_testEvents.Skip(2).Select(x => x.EventId).ToArray(),
res.Events.Select(x => x.Event.EventId).ToArray());
_conn.SetStreamMetadataAsync(stream, 0, StreamMetadata.Build().SetTruncateBefore(2).SetMaxCount(4)).Wait();
res = _conn.ReadStreamEventsForwardAsync(stream, 0, 100, false).Result;
Assert.AreEqual(SliceReadStatus.Success, res.Status);
Assert.AreEqual(3, res.Events.Length);
Assert.AreEqual(_testEvents.Skip(2).Select(x => x.EventId).ToArray(),
res.Events.Select(x => x.Event.EventId).ToArray());
}
protected override void When()
{
var metadata =
(StreamMetadata)
StreamMetadata.Build()
.SetMetadataReadRole("admin")
.SetMetadataWriteRole("admin")
.SetReadRole("")
.SetWriteRole("other");
var jsonMetadata = metadata.AsJsonString();
_response = MakeJsonPost(
TestMetadataStream,
new[]
{
new
{
EventId = Guid.NewGuid(),
EventType = SystemEventTypes.StreamMetadata,
Data = new JRaw(jsonMetadata)
}
});
}
public void after_setting_less_strict_truncatebefore_read_stream_backward_reads_more_events()
{
const string stream = "after_setting_less_strict_truncatebefore_read_stream_backward_reads_more_events";
_conn.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, _testEvents).Wait();
_conn.SetStreamMetadataAsync(stream, ExpectedVersion.EmptyStream, StreamMetadata.Build().SetTruncateBefore(2)).Wait();
var res = _conn.ReadStreamEventsBackwardAsync(stream, -1, 100, false).Result;
Assert.AreEqual(SliceReadStatus.Success, res.Status);
Assert.AreEqual(3, res.Events.Length);
Assert.AreEqual(_testEvents.Skip(2).Select(x => x.EventId).ToArray(),
res.Events.Reverse().Select(x => x.Event.EventId).ToArray());
_conn.SetStreamMetadataAsync(stream, 0, StreamMetadata.Build().SetTruncateBefore(1)).Wait();
res = _conn.ReadStreamEventsBackwardAsync(stream, -1, 100, false).Result;
Assert.AreEqual(SliceReadStatus.Success, res.Status);
Assert.AreEqual(4, res.Events.Length);
Assert.AreEqual(_testEvents.Skip(1).Select(x => x.EventId).ToArray(),
res.Events.Reverse().Select(x => x.Event.EventId).ToArray());
}
public void more_strict_max_count_gives_less_events_for_stream_backward_read()
{
const string stream = "more_strict_max_count_gives_less_events_for_stream_backward_read";
_conn.AppendToStreamAsync(stream, ExpectedVersion.EmptyStream, _testEvents).Wait();
_conn.SetStreamMetadataAsync(stream, ExpectedVersion.EmptyStream, StreamMetadata.Build().SetTruncateBefore(2)).Wait();
var res = _conn.ReadStreamEventsBackwardAsync(stream, -1, 100, false).Result;
Assert.AreEqual(SliceReadStatus.Success, res.Status);
Assert.AreEqual(3, res.Events.Length);
Assert.AreEqual(_testEvents.Skip(2).Select(x => x.EventId).ToArray(),
res.Events.Reverse().Select(x => x.Event.EventId).ToArray());
_conn.SetStreamMetadataAsync(stream, 0, StreamMetadata.Build().SetTruncateBefore(2).SetMaxCount(2)).Wait();
res = _conn.ReadStreamEventsBackwardAsync(stream, -1, 100, false).Result;
Assert.AreEqual(SliceReadStatus.Success, res.Status);
Assert.AreEqual(2, res.Events.Length);
Assert.AreEqual(_testEvents.Skip(3).Select(x => x.EventId).ToArray(),
res.Events.Reverse().Select(x => x.Event.EventId).ToArray());
}
setting_nonjson_metadata_on_empty_soft_deleted_stream_recreates_stream_keeping_original_metadataAsync()
{
const string stream =
"setting_nonjson_metadata_on_empty_soft_deleted_stream_recreates_stream_overriding_metadata";
await _conn.SetStreamMetadataAsync(stream, ExpectedVersion.Any, StreamMetadata.Build()
.SetTruncateBefore(long.MaxValue));
Assert.AreEqual(1, (await _conn.SetStreamMetadataAsync(stream, 0, new byte[256])).NextExpectedVersion);
await Task.Delay(50); //TODO: This is a workaround until github issue #1744 is fixed
var res = await _conn.ReadStreamEventsForwardAsync(stream, 0, 100, false);
Assert.AreEqual(SliceReadStatus.StreamNotFound, res.Status);
Assert.AreEqual(-1, res.LastEventNumber);
Assert.AreEqual(0, res.Events.Length);
var meta = await _conn.GetStreamMetadataAsRawBytesAsync(stream);
Assert.AreEqual(1, meta.MetastreamVersion);
Assert.AreEqual(new byte[256], meta.StreamMetadata);
}
public void after_setting_more_strict_truncatebefore_read_stream_forward_reads_less_events()
{
const string stream = "after_setting_more_strict_truncatebefore_read_stream_forward_reads_less_events";
_conn.AppendToStream(stream, ExpectedVersion.EmptyStream, _testEvents);
_conn.SetStreamMetadata(stream, ExpectedVersion.EmptyStream, StreamMetadata.Build().SetTruncateBefore(2));
var res = _conn.ReadStreamEventsForward(stream, 0, 100, false);
Assert.AreEqual(SliceReadStatus.Success, res.Status);
Assert.AreEqual(3, res.Events.Length);
Assert.AreEqual(_testEvents.Skip(2).Select(x => x.EventId).ToArray(),
res.Events.Select(x => x.Event.EventId).ToArray());
_conn.SetStreamMetadata(stream, 0, StreamMetadata.Build().SetTruncateBefore(3));
res = _conn.ReadStreamEventsForward(stream, 0, 100, false);
Assert.AreEqual(SliceReadStatus.Success, res.Status);
Assert.AreEqual(2, res.Events.Length);
Assert.AreEqual(_testEvents.Skip(3).Select(x => x.EventId).ToArray(),
res.Events.Select(x => x.Event.EventId).ToArray());
}
public void can_mutate_copy()
{
var source = StreamMetadata.Build()
.SetCacheControl(TimeSpan.FromDays(1))
.SetCustomProperty("Test", "Value")
.SetReadRole("foo")
.SetWriteRole("bar")
.SetDeleteRole("baz")
.SetMetadataReadRole("qux")
.SetMetadataWriteRole("quux")
.SetMaxAge(TimeSpan.FromHours(1))
.SetMaxCount(2)
.SetTruncateBefore(4)
.Build();
var expected = StreamMetadata.Build()
.SetCacheControl(TimeSpan.FromDays(1))
.SetCustomProperty("Test", "Value")
.SetCustomProperty("Test2", "Value2")
.SetReadRole("foo")
.SetWriteRole("bar")
.SetDeleteRole("baz")
.SetMetadataReadRole("qux")
.SetMetadataWriteRole("quux")
.SetMaxAge(TimeSpan.FromHours(1))
.SetMaxCount(4)
.SetTruncateBefore(4)
.Build();
var copied = source.Copy()
.SetMaxCount(4)
.SetCustomProperty("Test2", "Value2")
.Build();
Assert.AreEqual(expected.AsJsonString(), copied.AsJsonString());
}
protected override void When()
{
_conn.SetStreamMetadataAsync("$all", -1,
StreamMetadata.Build().SetReadRole(SystemRoles.All),
DefaultData.AdminCredentials)
.Wait();
_testEvents = Enumerable.Range(0, 20).Select(x => TestEvent.NewTestEvent(x.ToString())).ToArray();
_conn.AppendToStreamAsync("stream-" + Guid.NewGuid(), ExpectedVersion.EmptyStream, _testEvents).Wait();
var result = _conn.AppendToStreamAsync("stream-" + Guid.NewGuid(), ExpectedVersion.NoStream,
TestEvent.NewTestEvent()).Result;
var lastId = _testEvents.Last().EventId;
_endOfEvents = result.LogPosition;
do
{
var slice = _conn.ReadAllEventsBackwardAsync(_endOfEvents, 1, false).Result;
if (slice.Events[0].Event.EventId == lastId)
{
break;
}
_endOfEvents = slice.NextPosition;
} while (true);
}
public void soft_deleted_stream_when_recreated_preserves_metadata_except_truncatebefore()
{
const string stream = "soft_deleted_stream_when_recreated_preserves_metadata_except_truncatebefore";
Assert.AreEqual(1, _conn.AppendToStream(stream, ExpectedVersion.NoStream, TestEvent.NewTestEvent(), TestEvent.NewTestEvent()).NextExpectedVersion);
Assert.AreEqual(0, _conn.SetStreamMetadata(stream, ExpectedVersion.NoStream,
StreamMetadata.Build().SetTruncateBefore(int.MaxValue)
.SetMaxCount(100)
.SetDeleteRole("some-role")
.SetCustomProperty("key1", true)
.SetCustomProperty("key2", 17)
.SetCustomProperty("key3", "some value")).NextExpectedVersion);
var events = new[] { TestEvent.NewTestEvent(), TestEvent.NewTestEvent(), TestEvent.NewTestEvent() };
Assert.AreEqual(4, _conn.AppendToStream(stream, 1, events).NextExpectedVersion);
var res = _conn.ReadStreamEventsForward(stream, 0, 100, false);
Assert.AreEqual(SliceReadStatus.Success, res.Status);
Assert.AreEqual(4, res.LastEventNumber);
Assert.AreEqual(3, res.Events.Length);
Assert.AreEqual(events.Select(x => x.EventId), res.Events.Select(x => x.OriginalEvent.EventId));
Assert.AreEqual(new[] { 2, 3, 4 }, res.Events.Select(x => x.OriginalEvent.EventNumber));
var meta = _conn.GetStreamMetadata(stream);
Assert.AreEqual(1, meta.MetastreamVersion);
Assert.AreEqual(2, meta.StreamMetadata.TruncateBefore);
Assert.AreEqual(100, meta.StreamMetadata.MaxCount);
Assert.AreEqual("some-role", meta.StreamMetadata.Acl.DeleteRole);
Assert.AreEqual(true, meta.StreamMetadata.GetValue <bool>("key1"));
Assert.AreEqual(17, meta.StreamMetadata.GetValue <int>("key2"));
Assert.AreEqual("some value", meta.StreamMetadata.GetValue <string>("key3"));
}
public void deleting_system_all_stream_with_admin_user_is_allowed()
{
var streamId = CreateStreamWithMeta(streamPrefix: "$", metadata: StreamMetadata.Build().SetDeleteRole(SystemRoles.All));
ExpectNoException(() => DeleteStream(streamId, "adm", "admpa$$"));
}
public async Task WriteMetadata(string stream, int?maxCount = null, int?truncateBefore = null, TimeSpan?maxAge = null,
TimeSpan?cacheControl = null, bool?frozen = null, Guid?owner = null)
{
Logger.Write(LogLevel.Debug, () => $"Writing metadata to stream [{stream}] [ {nameof(maxCount)}: {maxCount}, {nameof(maxAge)}: {maxAge}, {nameof(cacheControl)}: {cacheControl}, {nameof(frozen)}: {frozen} ]");
var existing = await _client.GetStreamMetadataAsync(stream).ConfigureAwait(false);
if ((existing.StreamMetadata?.CustomKeys.Contains("frozen") ?? false) &&
existing.StreamMetadata?.GetValue <string>("owner") != Defaults.Instance.ToString())
{
FrozenExceptions.Mark();
throw new VersionException("Stream is frozen - we are not the owner");
}
if (frozen.HasValue && frozen == false && (
existing.StreamMetadata == null ||
(existing.StreamMetadata?.CustomKeys.Contains("frozen") ?? false) == false ||
existing.StreamMetadata?.GetValue <string>("owner") != Defaults.Instance.ToString()))
{
FrozenExceptions.Mark();
throw new FrozenException();
}
// If we are trying to freeze the stream that we've already frozen (to prevent multiple threads from attempting to process the same frozen data)
if (frozen.HasValue && frozen == true && (existing.StreamMetadata?.CustomKeys.Contains("frozen") ?? false) &&
existing.StreamMetadata?.GetValue <string>("owner") == Defaults.Instance.ToString())
{
FrozenExceptions.Mark();
throw new FrozenException();
}
var metadata = StreamMetadata.Build();
if ((maxCount ?? existing.StreamMetadata?.MaxCount).HasValue)
{
metadata.SetMaxCount((maxCount ?? existing.StreamMetadata?.MaxCount).Value);
}
if ((truncateBefore ?? existing.StreamMetadata?.TruncateBefore).HasValue)
{
metadata.SetTruncateBefore((truncateBefore ?? existing.StreamMetadata?.TruncateBefore).Value);
}
if ((maxAge ?? existing.StreamMetadata?.MaxAge).HasValue)
{
metadata.SetMaxAge((maxAge ?? existing.StreamMetadata?.MaxAge).Value);
}
if ((cacheControl ?? existing.StreamMetadata?.CacheControl).HasValue)
{
metadata.SetCacheControl((cacheControl ?? existing.StreamMetadata?.CacheControl).Value);
}
if (frozen.HasValue && frozen == true)
{
metadata.SetCustomProperty("frozen", DateTime.UtcNow.ToUnixTime());
}
if (owner.HasValue)
{
metadata.SetCustomProperty("owner", Defaults.Instance.ToString());
}
try
{
await _client.SetStreamMetadataAsync(stream, existing.MetastreamVersion, metadata).ConfigureAwait(false);
}
catch (WrongExpectedVersionException e)
{
throw new VersionException(e.Message, e);
}
catch (CannotEstablishConnectionException e)
{
throw new PersistenceException(e.Message, e);
}
catch (OperationTimedOutException e)
{
throw new PersistenceException(e.Message, e);
}
catch (EventStoreConnectionException e)
{
throw new PersistenceException(e.Message, e);
}
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
Connection.SetStreamMetadataAsync("$all", ExpectedVersion.Any, StreamMetadata.Build(), new UserCredentials("adm", "admpa$$")).Wait();
}
public virtual void OneTimeSetUp()
{
Connection = SetupConnection();
Connection.ConnectAsync().Wait();
var manager = new UsersManager(new NoopLogger(), TestNode.HttpEndPoint, TimeSpan.FromSeconds(10));
CreateUsers(manager);
Connection.SetStreamMetadataAsync(AdjustStreamId("noacl-stream"), ExpectedVersion.Any, StreamMetadata.Build())
.Wait();
Connection.SetStreamMetadataAsync(
AdjustStreamId("read-stream"),
ExpectedVersion.Any,
StreamMetadata.Build().SetReadRole("user1")).Wait();
Connection.SetStreamMetadataAsync(
AdjustStreamId("write-stream"),
ExpectedVersion.Any,
StreamMetadata.Build().SetWriteRole("user1")).Wait();
Connection.SetStreamMetadataAsync(
AdjustStreamId("metaread-stream"),
ExpectedVersion.Any,
StreamMetadata.Build().SetMetadataReadRole("user1")).Wait();
Connection.SetStreamMetadataAsync(
AdjustStreamId("metawrite-stream"),
ExpectedVersion.Any,
StreamMetadata.Build().SetMetadataWriteRole("user1")).Wait();
Connection.SetStreamMetadataAsync(
AdjustStreamId("$all"),
ExpectedVersion.Any,
StreamMetadata.Build().SetReadRole("user1"),
new UserCredentials("adm", "admpa$$")).Wait();
Connection.SetStreamMetadataAsync(
AdjustStreamId("$system-acl"),
ExpectedVersion.Any,
StreamMetadata.Build()
.SetReadRole("user1")
.SetWriteRole("user1")
.SetMetadataReadRole("user1")
.SetMetadataWriteRole("user1"),
new UserCredentials("adm", "admpa$$")).Wait();
Connection.SetStreamMetadataAsync(
AdjustStreamId("$system-adm"),
ExpectedVersion.Any,
StreamMetadata.Build()
.SetReadRole(SystemRoles.Admins)
.SetWriteRole(SystemRoles.Admins)
.SetMetadataReadRole(SystemRoles.Admins)
.SetMetadataWriteRole(SystemRoles.Admins),
new UserCredentials("adm", "admpa$$")).Wait();
Connection.SetStreamMetadataAsync(
AdjustStreamId("normal-all"),
ExpectedVersion.Any,
StreamMetadata.Build()
.SetReadRole(SystemRoles.All)
.SetWriteRole(SystemRoles.All)
.SetMetadataReadRole(SystemRoles.All)
.SetMetadataWriteRole(SystemRoles.All)).Wait();
Connection.SetStreamMetadataAsync(
AdjustStreamId("$system-all"),
ExpectedVersion.Any,
StreamMetadata.Build()
.SetReadRole(SystemRoles.All)
.SetWriteRole(SystemRoles.All)
.SetMetadataReadRole(SystemRoles.All)
.SetMetadataWriteRole(SystemRoles.All),
new UserCredentials("adm", "admpa$$")).Wait();
}
public virtual void OneTimeTearDown()
{
Connection.SetStreamMetadataAsync("$all", ExpectedVersion.Any, StreamMetadata.Build(),
TestNode.AdminCredentials).Wait();
Connection.SetSystemSettingsAsync(new SystemSettings(null, null), TestNode.AdminCredentials).Wait();
}
public override void TestFixtureSetUp()
{
base.TestFixtureSetUp();
_node = new MiniNode(PathName, enableTrustedAuth: true);
_node.Start();
var userCreateEvent1 = new ManualResetEventSlim();
_node.Node.MainQueue.Publish(
new UserManagementMessage.Create(
new CallbackEnvelope(
m =>
{
Assert.IsTrue(m is UserManagementMessage.UpdateResult);
var msg = (UserManagementMessage.UpdateResult)m;
Assert.IsTrue(msg.Success);
userCreateEvent1.Set();
}), SystemAccount.Principal, "user1", "Test User 1", new string[0], "pa$$1"));
var userCreateEvent2 = new ManualResetEventSlim();
_node.Node.MainQueue.Publish(
new UserManagementMessage.Create(
new CallbackEnvelope(
m =>
{
Assert.IsTrue(m is UserManagementMessage.UpdateResult);
var msg = (UserManagementMessage.UpdateResult)m;
Assert.IsTrue(msg.Success);
userCreateEvent2.Set();
}), SystemAccount.Principal, "user2", "Test User 2", new string[0], "pa$$2"));
var adminCreateEvent2 = new ManualResetEventSlim();
_node.Node.MainQueue.Publish(
new UserManagementMessage.Create(
new CallbackEnvelope(
m =>
{
Assert.IsTrue(m is UserManagementMessage.UpdateResult);
var msg = (UserManagementMessage.UpdateResult)m;
Assert.IsTrue(msg.Success);
adminCreateEvent2.Set();
}), SystemAccount.Principal, "adm", "Administrator User", new[] { SystemRoles.Admins }, "admpa$$"));
Assert.IsTrue(userCreateEvent1.Wait(120000), "User 1 creation failed");
Assert.IsTrue(userCreateEvent2.Wait(120000), "User 2 creation failed");
Assert.IsTrue(adminCreateEvent2.Wait(120000), "Administrator User creation failed");
Connection = TestConnection.Create(_node.TcpEndPoint, TcpType.Normal, _userCredentials);
Connection.Connect();
Connection.SetStreamMetadata("noacl-stream", ExpectedVersion.NoStream, StreamMetadata.Build());
Connection.SetStreamMetadata("read-stream", ExpectedVersion.NoStream, StreamMetadata.Build().SetReadRole("user1"));
Connection.SetStreamMetadata("write-stream", ExpectedVersion.NoStream, StreamMetadata.Build().SetWriteRole("user1"));
Connection.SetStreamMetadata("metaread-stream", ExpectedVersion.NoStream, StreamMetadata.Build().SetMetadataReadRole("user1"));
Connection.SetStreamMetadata("metawrite-stream", ExpectedVersion.NoStream, StreamMetadata.Build().SetMetadataWriteRole("user1"));
Connection.SetStreamMetadata("$all", ExpectedVersion.Any, StreamMetadata.Build().SetReadRole("user1"), new UserCredentials("adm", "admpa$$"));
Connection.SetStreamMetadata("$system-acl", ExpectedVersion.NoStream,
StreamMetadata.Build()
.SetReadRole("user1")
.SetWriteRole("user1")
.SetMetadataReadRole("user1")
.SetMetadataWriteRole("user1"), new UserCredentials("adm", "admpa$$"));
Connection.SetStreamMetadata("$system-adm", ExpectedVersion.NoStream,
StreamMetadata.Build()
.SetReadRole(SystemRoles.Admins)
.SetWriteRole(SystemRoles.Admins)
.SetMetadataReadRole(SystemRoles.Admins)
.SetMetadataWriteRole(SystemRoles.Admins), new UserCredentials("adm", "admpa$$"));
Connection.SetStreamMetadata("normal-all", ExpectedVersion.NoStream,
StreamMetadata.Build()
.SetReadRole(SystemRoles.All)
.SetWriteRole(SystemRoles.All)
.SetMetadataReadRole(SystemRoles.All)
.SetMetadataWriteRole(SystemRoles.All));
Connection.SetStreamMetadata("$system-all", ExpectedVersion.NoStream,
StreamMetadata.Build()
.SetReadRole(SystemRoles.All)
.SetWriteRole(SystemRoles.All)
.SetMetadataReadRole(SystemRoles.All)
.SetMetadataWriteRole(SystemRoles.All), new UserCredentials("adm", "admpa$$"));
}
public async Task WriteMetadata(string stream, long?maxCount = null, long?truncateBefore = null,
TimeSpan?maxAge = null,
TimeSpan?cacheControl = null, bool force = false, IDictionary <string, string> custom = null)
{
var shard = Math.Abs(stream.GetHash() % _clients.Count());
Logger.DebugEvent("Metadata", "Metadata to stream [{Stream:l}] [ MaxCount: {MaxCount}, MaxAge: {MaxAge}, CacheControl: {CacheControl}, Custom: {Custom} ]", stream, maxCount, maxAge, cacheControl, custom.AsString());
var existing = await _clients[shard].GetStreamMetadataAsync(stream).ConfigureAwait(false);
var metadata = StreamMetadata.Build();
if ((maxCount ?? existing.StreamMetadata?.MaxCount).HasValue)
{
metadata.SetMaxCount((maxCount ?? existing.StreamMetadata?.MaxCount).Value);
}
if ((truncateBefore ?? existing.StreamMetadata?.TruncateBefore).HasValue)
{
metadata.SetTruncateBefore(Math.Max(truncateBefore ?? 0, (truncateBefore ?? existing.StreamMetadata?.TruncateBefore).Value));
}
if ((maxAge ?? existing.StreamMetadata?.MaxAge).HasValue)
{
metadata.SetMaxAge((maxAge ?? existing.StreamMetadata?.MaxAge).Value);
}
if ((cacheControl ?? existing.StreamMetadata?.CacheControl).HasValue)
{
metadata.SetCacheControl((cacheControl ?? existing.StreamMetadata?.CacheControl).Value);
}
var customs = existing.StreamMetadata?.CustomKeys;
// Make sure custom metadata is preserved
if (customs != null && customs.Any())
{
foreach (var key in customs)
{
metadata.SetCustomProperty(key, existing.StreamMetadata.GetValue <string>(key));
}
}
if (custom != null)
{
foreach (var kv in custom)
{
metadata.SetCustomProperty(kv.Key, kv.Value);
}
}
try
{
try
{
await _clients[shard].SetStreamMetadataAsync(stream, existing.MetastreamVersion, metadata).ConfigureAwait(false);
}
catch (WrongExpectedVersionException e)
{
throw new VersionException(e.Message, e);
}
catch (CannotEstablishConnectionException e)
{
throw new PersistenceException(e.Message, e);
}
catch (OperationTimedOutException e)
{
throw new PersistenceException(e.Message, e);
}
catch (EventStoreConnectionException e)
{
throw new PersistenceException(e.Message, e);
}
}
catch (Exception ex)
{
Logger.WarnEvent("MetadataFailure", ex, "{ExceptionType} - {ExceptionMessage}", ex.GetType().Name, ex.Message);
throw;
}
}
public void deleting_normal_all_stream_with_no_user_is_allowed()
{
var streamId = CreateStreamWithMeta(StreamMetadata.Build().SetDeleteRole(SystemRoles.All));
ExpectNoException(() => DeleteStream(streamId, null, null));
}
public override void OneTimeTearDown()
{
_conn.SetStreamMetadataAsync("$all", ExpectedVersion.Any,
StreamMetadata.Build(),
DefaultData.AdminCredentials);
}
public void deleting_normal_admin_stream_with_existing_user_is_not_allowed()
{
var streamId = CreateStreamWithMeta(StreamMetadata.Build().SetDeleteRole(SystemRoles.Admins));
Expect <AccessDeniedException>(() => DeleteStream(streamId, "user1", "pa$$1"));
}
public void deleting_normal_admin_stream_with_admin_user_is_allowed()
{
var streamId = CreateStreamWithMeta(StreamMetadata.Build().SetDeleteRole(SystemRoles.Admins));
ExpectNoException(() => DeleteStream(streamId, "adm", "admpa$$"));
}
public void deleting_normal_user_stream_with_authorized_user_is_allowed()
{
var streamId = CreateStreamWithMeta(StreamMetadata.Build().SetDeleteRole("user1"));
ExpectNoException(() => DeleteStream(streamId, "user1", "pa$$1"));
}
public void deleting_normal_user_stream_with_not_authorized_user_is_not_allowed()
{
var streamId = CreateStreamWithMeta(StreamMetadata.Build().SetDeleteRole("user1"));
Expect <AccessDeniedException>(() => DeleteStream(streamId, "user2", "pa$$2"));
}
public void deleting_normal_no_acl_stream_with_admin_user_is_allowed()
{
var streamId = CreateStreamWithMeta(StreamMetadata.Build());
ExpectNoException(() => DeleteStream(streamId, "adm", "admpa$$"));
}
public void deleting_system_no_acl_stream_with_existing_user_is_not_allowed()
{
var streamId = CreateStreamWithMeta(streamPrefix: "$", metadata: StreamMetadata.Build());
Expect <AccessDeniedException>(() => DeleteStream(streamId, "user1", "pa$$1"));
}
public void deleting_system_admin_stream_with_no_user_is_not_allowed()
{
var streamId = CreateStreamWithMeta(streamPrefix: "$", metadata: StreamMetadata.Build().SetDeleteRole(SystemRoles.Admins));
Expect <AccessDeniedException>(() => DeleteStream(streamId, null, null));
}
