public void GetInstanceAsync_Cancel_ShouldCancelWait() { SyncTestHelpers.RunRosTestAsync(async() => { var config = await SyncTestHelpers.GetIntegrationConfigAsync("foo"); await PopulateData(config); // Update config to make sure we're not opening the same Realm file. config = new FullSyncConfiguration(config.ServerUri, config.User, config.DatabasePath + "1"); using (var cts = new CancellationTokenSource()) { var _ = Task.Run(async() => { await Task.Delay(1); cts.Cancel(); }); try { var realm = await Realm.GetInstanceAsync(config, cts.Token); CleanupOnTearDown(realm); Assert.Fail("Expected task to be cancelled."); } catch (Exception ex) { Assert.That(ex, Is.InstanceOf <TaskCanceledException>()); } } }); }
public void GetInstanceAsync_ReportsProgress() { SyncTestHelpers.RunRosTestAsync(async() => { var config = await SyncTestHelpers.GetIntegrationConfigAsync("foo"); await PopulateData(config); var callbacksInvoked = 0; var lastProgress = default(SyncProgress); config = new FullSyncConfiguration(config.ServerUri, config.User, config.DatabasePath + "1") { OnProgress = (progress) => { callbacksInvoked++; lastProgress = progress; } }; using (var realm = await GetRealmAsync(config)) { Assert.That(realm.All <HugeSyncObject>().Count(), Is.EqualTo(NumberOfObjects)); Assert.That(callbacksInvoked, Is.GreaterThan(0)); Assert.That(lastProgress.TransferableBytes, Is.EqualTo(lastProgress.TransferredBytes)); } }); }
public void User_InvalidateOffer_InvalidatesTheOffer() { SyncTestHelpers.RunRosTestAsync(async() => { var alice = await SyncTestHelpers.GetUserAsync(); var bob = await SyncTestHelpers.GetUserAsync(); var charlie = await SyncTestHelpers.GetUserAsync(); var realmUrl = SyncTestHelpers.RealmUri($"{alice.Identity}/testPermission").AbsoluteUri; await EnsureRealmExists(alice, realmUrl); var token = await alice.OfferPermissionsAsync(realmUrl, AccessLevel.Write); var bobUrl = await bob.AcceptPermissionOfferAsync(token); Assert.That(bobUrl, Is.EqualTo($"/{alice.Identity}/testPermission")); await alice.InvalidateOfferAsync(token); await TestHelpers.AssertThrows <HttpException>(() => charlie.AcceptPermissionOfferAsync(token), ex => { Assert.That(ex.StatusCode, Is.EqualTo(HttpStatusCode.Forbidden)); Assert.That(ex.ErrorCode, Is.EqualTo(ErrorCode.ExpiredPermissionOffer)); Assert.That(ex.Message, Is.EqualTo("The permission offer is expired.")); }); }); }
public void SyncConfiguration_LoggerFactory_Test(LogLevel logLevel) { SyncTestHelpers.RunRosTestAsync(async() => { var logBuilder = new StringBuilder(); SyncConfigurationBase.CustomLogger = (message, level) => { logBuilder.AppendLine($"[{level}] {message}"); }; SyncConfigurationBase.LogLevel = logLevel; var config = await SyncTestHelpers.GetIntegrationConfigAsync(Guid.NewGuid().ToString()); using (var realm = await GetRealmAsync(config)) { realm.Write(() => { realm.Add(new Person()); }); await SyncTestHelpers.WaitForUploadAsync(realm); } var log = logBuilder.ToString(); Assert.That(log, Does.Contain($"[{logLevel}]")); Assert.That(log, Does.Not.Contain($"[{(logLevel - 1)}]")); }); }
public void NamedSubscription_CanUnsubscribe(bool openAsync) { SyncTestHelpers.RunRosTestAsync(async() => { using (var realm = await GetQueryBasedRealm(openAsync)) { var query = realm.All <ObjectA>().Where(o => o.IntValue < 5); var subscription = query.Subscribe(new SubscriptionOptions { Name = "query" }); await subscription.WaitForSynchronizationAsync().Timeout(2000); Assert.That(subscription.Results.Count(), Is.EqualTo(5)); await subscription.UnsubscribeAsync(); Assert.That(subscription.State, Is.EqualTo(SubscriptionState.Invalidated)); await TestHelpers.WaitForConditionAsync(() => query.Count() == 0); Assert.That(query.Count(), Is.EqualTo(0)); Assert.That(subscription.Results.Count(), Is.EqualTo(0)); } }); }
public void TestManualClientResync() { SyncTestHelpers.RunRosTestAsync(async() => { var config = await GetClientResyncConfig(ClientResyncMode.Manual); Realm.DeleteRealm(config); using (var realm = await Realm.GetInstanceAsync(config)) { realm.Write(() => { realm.Add(new IntPrimaryKeyWithValueObject()); }); await WaitForUploadAsync(realm); } // Delete Realm in ROS Debugger.Break(); Exception ex = null; Session.Error += (s, e) => { ex = e.Exception; }; using (var realm = Realm.GetInstance(config)) { await Task.Delay(100); } Assert.That(ex, Is.InstanceOf <ClientResetException>()); }); }
public void NamedSubscription_CanResubscribe(bool openAsync) { SyncTestHelpers.RunRosTestAsync(async() => { using (var realm = await GetQueryBasedRealm(openAsync)) { var query = realm.All <ObjectA>().Where(o => o.IntValue < 5); var subscription = query.Subscribe(new SubscriptionOptions { Name = "less than 5" }); await subscription.WaitForSynchronizationAsync().Timeout(2000); Assert.That(subscription.Results.Count(), Is.EqualTo(5)); var subscription2 = realm.All <ObjectA>().Where(o => o.IntValue < 5).Subscribe(new SubscriptionOptions { Name = "less than 5" }); await subscription2.WaitForSynchronizationAsync().Timeout(2000); Assert.That(subscription.Results.Count(), Is.EqualTo(5)); Assert.That(subscription2.Results.Count(), Is.EqualTo(5)); } }); }
public void NamedSubscription_CannotChangeQuery(bool openAsync) { SyncTestHelpers.RunRosTestAsync(async() => { using (var realm = await GetQueryBasedRealm(openAsync)) { var query = realm.All <ObjectA>().Where(o => o.IntValue < 5); var subscription = query.Subscribe(new SubscriptionOptions { Name = "foo" }); await subscription.WaitForSynchronizationAsync().Timeout(2000); Assert.That(subscription.Results.Count(), Is.EqualTo(5)); var subscription2 = realm.All <ObjectA>() .Where(o => o.IntValue > 5) .Subscribe(new SubscriptionOptions { Name = "foo" }); await TestHelpers.AssertThrows <RealmException>(() => subscription2.WaitForSynchronizationAsync(), ex => { Assert.That(subscription2.State, Is.EqualTo(SubscriptionState.Error)); Assert.That(subscription2.Error, Is.Not.Null); Assert.That(subscription2.Error.Message, Does.Contain("An existing subscription exists with the name")); Assert.That(ex, Is.EqualTo(subscription2.Error)); }); } }); }
public void Subscription_GetAll_FindsSubscription(bool openAsync, bool isNamed) { SyncTestHelpers.RunRosTestAsync(async() => { using (var realm = await GetQueryBasedRealm(openAsync)) { var name = isNamed ? "some subscription" : null; var query = realm.All <ObjectA>().Where(o => o.IntValue < 5); var now = DateTimeOffset.UtcNow; var subscription = query.Subscribe(new SubscriptionOptions { Name = name }); await subscription.WaitForSynchronizationAsync().Timeout(2000); var sub = realm.GetAllSubscriptions().FirstOrDefault(s => s.ObjectType == nameof(ObjectA)); Assert.That(sub, Is.Not.Null); Assert.That(sub.Error, Is.Null); Assert.That(sub.Name, isNamed ? (IResolveConstraint)Is.EqualTo(name) : Is.Not.Null); Assert.That(sub.ObjectType, Is.EqualTo(nameof(ObjectA))); Assert.That(sub.CreatedAt, Is.InRange(now, now.AddSeconds(2))); Assert.That(sub.CreatedAt, Is.EqualTo(sub.UpdatedAt)); Assert.That(sub.ExpiresAt, Is.Null); Assert.That(sub.TimeToLive, Is.Null); } }); }
public void UserLogout_RevokesRefreshToken() { SyncTestHelpers.RunRosTestAsync(async() => { var userId = Guid.NewGuid().ToString(); var credentials = Credentials.UsernamePassword(userId, OriginalPassword, createUser: true); var user = await User.LoginAsync(credentials, SyncTestHelpers.AuthServerUri); var token = user.RefreshToken; await user.LogOutAsync(); // Changing user's password uses the RefreshToken as authorization var json = new Dictionary <string, object> { ["data"] = new Dictionary <string, object> { ["new_password"] = "******" } }; await TestHelpers.AssertThrows <HttpException>( () => AuthenticationHelper.MakeAuthRequestAsync(HttpMethod.Put, new Uri(SyncTestHelpers.AuthServerUri, "auth/password"), json, token), ex => { Assert.That(ex.StatusCode, Is.EqualTo(HttpStatusCode.Forbidden)); Assert.That(ex.ErrorCode, Is.EqualTo(ErrorCode.AccessDenied)); }); }); }
public void SubscribeForObjects_WhenTwoQueriesOverlap_SynchronizesTheUnion(bool openAsync) { SyncTestHelpers.RunRosTestAsync(async() => { using (var realm = await GetQueryBasedRealm(openAsync)) { var youngerThan3Subscription = realm.All <ObjectA>().Where(o => o.IntValue < 3).Subscribe(); var range1to6Subscription = realm.All <ObjectA>().Where(o => o.IntValue > 1 && o.IntValue < 6).Subscribe(); await youngerThan3Subscription.WaitForSynchronizationAsync().Timeout(2000); await range1to6Subscription.WaitForSynchronizationAsync().Timeout(2000); var youngerThan3 = youngerThan3Subscription.Results; var range1to6 = range1to6Subscription.Results; Assert.That(youngerThan3.Count(), Is.EqualTo(3)); Assert.That(range1to6.Count(), Is.EqualTo(4)); Assert.That(youngerThan3.ToArray().All(o => o.IntValue < 3)); Assert.That(range1to6.ToArray().All(o => o.IntValue > 1 && o.IntValue < 6)); var allInRealm = realm.All <ObjectA>(); Assert.That(allInRealm.Count(), Is.EqualTo(6)); Assert.That(allInRealm.ToArray().All(o => o.IntValue < 6)); } }); }
public void Test_ObjectDelete() { SyncTestHelpers.RunRosTestAsync(async() => { var userA = await SyncTestHelpers.GetUserAsync(); var userB = await SyncTestHelpers.GetUserAsync(); var realmUri = await CreateRealm(r => { var reader = PermissionRole.Get(r, "reader"); reader.Users.Add(userA); reader.Users.Add(userB); var writer = PermissionRole.Get(r, "writer"); writer.Users.Add(userA); var obj1 = r.Add(new ObjectWithPermissions { Id = 1, StringValue = "Value 1" }); CreatePermissions(obj1.Permissions); }, addObjects: false); using (var realmA = GetRealm(userA, realmUri)) using (var realmB = GetRealm(userB, realmUri)) { var subscriptionB = await SubscribeToObjectsAsync(realmB); var objB = subscriptionB.Results.Single(); realmB.Write(() => { realmB.Remove(objB); }); Assert.That(subscriptionB.Results.Count(), Is.Zero); await SyncTestHelpers.WaitForSyncAsync(realmB); Assert.That(subscriptionB.Results.Count(), Is.EqualTo(1)); objB = subscriptionB.Results.Single(); var subscriptionA = await SubscribeToObjectsAsync(realmA); var objA = subscriptionA.Results.Single(); realmA.Write(() => { realmA.Remove(objA); }); await SyncTestHelpers.WaitForSyncAsync(realmA); await SyncTestHelpers.WaitForSyncAsync(realmB); Assert.That(subscriptionA.Results.Count(), Is.Zero); Assert.That(subscriptionB.Results.Count(), Is.Zero); Assert.That(objA.IsValid, Is.False); Assert.That(objB.IsValid, Is.False); } }); }
public void UserLookup_WhenUserIsNotAdmin_ShouldThrow() { SyncTestHelpers.RunRosTestAsync(async() => { var alice = await SyncTestHelpers.GetUserAsync(); await TestHelpers.AssertThrows <InvalidOperationException>(() => alice.RetrieveInfoForUserAsync(Credentials.Provider.UsernamePassword, "some-id")); }); }
public void Test_ClassUpdate() { SyncTestHelpers.RunRosTestAsync(async() => { var userA = await SyncTestHelpers.GetUserAsync(); var userB = await SyncTestHelpers.GetUserAsync(); var realmUri = await CreateRealm(r => { CreatePermissions(ClassPermission.Get <ObjectWithPermissions>(r).Permissions); var reader = PermissionRole.Get(r, "reader"); reader.Users.Add(userA); reader.Users.Add(userB); var writer = PermissionRole.Get(r, "writer"); writer.Users.Add(userA); }); using (var realm = GetRealm(userA, realmUri)) { var subscription = await SubscribeToObjectsAsync(realm); AssertRealmPrivileges(realm, RealmPrivileges.Read | RealmPrivileges.Update | RealmPrivileges.ModifySchema | RealmPrivileges.SetPermissions); AssertClassPrivileges(realm, ClassPrivileges.Read | ClassPrivileges.Subscribe | ClassPrivileges.Update | ClassPrivileges.Create); AssertObjectPrivileges(realm, ObjectPrivileges.Read | ObjectPrivileges.Update | ObjectPrivileges.Delete | ObjectPrivileges.SetPermissions); var obj = realm.Find <ObjectWithPermissions>(1); realm.Write(() => { obj.StringValue = "New value"; }); await SyncTestHelpers.WaitForSyncAsync(realm); Assert.That(obj.StringValue, Is.EqualTo("New value")); } using (var realm = GetRealm(userB, realmUri)) { var subscription = await SubscribeToObjectsAsync(realm); AssertRealmPrivileges(realm, RealmPrivileges.Read | RealmPrivileges.Update | RealmPrivileges.ModifySchema | RealmPrivileges.SetPermissions); AssertClassPrivileges(realm, ClassPrivileges.Read | ClassPrivileges.Subscribe); AssertObjectPrivileges(realm, ObjectPrivileges.Read); var obj = realm.Find <ObjectWithPermissions>(1); realm.Write(() => { obj.StringValue = "New value 2"; }); Assert.That(obj.StringValue, Is.EqualTo("New value 2")); await SyncTestHelpers.WaitForSyncAsync(realm); // Change is reverted Assert.That(obj.StringValue, Is.EqualTo("New value")); } }); }
public void User_ApplyPermissions_WithUserId_GrantsAndRevokesPermissions() { SyncTestHelpers.RunRosTestAsync(async() => { var alice = await SyncTestHelpers.GetUserAsync(); var bob = await SyncTestHelpers.GetUserAsync(); await TestApplyPermissions(alice, bob, PermissionCondition.UserId(bob.Identity)).Timeout(20000); }); }
public void UserLookup_WhenTargetUserDoesNotExist_ShouldReturnNull() { SyncTestHelpers.RunRosTestAsync(async() => { var admin = await User.LoginAsync(SyncTestHelpers.AdminCredentials(), SyncTestHelpers.AuthServerUri); var lookupResponse = await admin.RetrieveInfoForUserAsync(Credentials.Provider.UsernamePassword, "something"); Assert.That(lookupResponse, Is.Null); }); }
public void UserLogin_WhenNickname_LogsUserIn() { SyncTestHelpers.RunRosTestAsync(async() => { var credentials = Credentials.Nickname(Guid.NewGuid().ToString()); var user = await User.LoginAsync(credentials, SyncTestHelpers.AuthServerUri); Assert.That(user, Is.Not.Null); Assert.That(user.Identity, Is.Not.Null); }); }
public void UserLogin_WhenAnonymous_LogsUserIn() { SyncTestHelpers.RunRosTestAsync(async() => { var credentials = Credentials.Anonymous(); var user = await User.LoginAsync(credentials, SyncTestHelpers.AuthServerUri); Assert.That(user, Is.Not.Null); Assert.That(user.Identity, Is.Not.Null); }); }
public void Test_ObjectUpdate() { SyncTestHelpers.RunRosTestAsync(async() => { var userA = await SyncTestHelpers.GetUserAsync(); var userB = await SyncTestHelpers.GetUserAsync(); var realmUri = await CreateRealm(r => { var reader = PermissionRole.Get(r, "reader"); reader.Users.Add(userA); reader.Users.Add(userB); var writer = PermissionRole.Get(r, "writer"); writer.Users.Add(userA); var obj1 = r.Add(new ObjectWithPermissions { Id = 1, StringValue = "Value 1" }); CreatePermissions(obj1.Permissions); }, addObjects: false); using (var realm = GetRealm(userA, realmUri)) { var subscription = await SubscribeToObjectsAsync(realm); var obj1 = subscription.Results.Single(); realm.Write(() => { obj1.StringValue = "New value"; }); await SyncTestHelpers.WaitForSyncAsync(realm); Assert.That(obj1.StringValue, Is.EqualTo("New value")); } using (var realm = GetRealm(userB, realmUri)) { var subscription = await SubscribeToObjectsAsync(realm); var obj1 = subscription.Results.Single(); realm.Write(() => { obj1.StringValue = "New value #2"; }); Assert.That(obj1.StringValue, Is.EqualTo("New value #2")); await SyncTestHelpers.WaitForSyncAsync(realm); Assert.That(obj1.StringValue, Is.EqualTo("New value")); } }); }
public void UserLogin_WhenAnonymousAndDifferentCredentials_ShouldLoginDifferentUser() { SyncTestHelpers.RunRosTestAsync(async() => { var first = await User.LoginAsync(Credentials.Anonymous(), SyncTestHelpers.AuthServerUri); var second = await User.LoginAsync(Credentials.Anonymous(), SyncTestHelpers.AuthServerUri); Assert.That(first.Identity, Is.Not.EqualTo(second.Identity)); Assert.That(User.AllLoggedIn.Length, Is.EqualTo(2)); }); }
public void User_OfferPermissions_WhenNoAccess_ShouldThrow() { SyncTestHelpers.RunRosTestAsync(async() => { var alice = await SyncTestHelpers.GetUserAsync(); var realmUrl = SyncTestHelpers.RealmUri($"{alice.Identity}/testPermission").AbsoluteUri; await EnsureRealmExists(alice, realmUrl); await TestHelpers.AssertThrows <ArgumentException>(() => alice.OfferPermissionsAsync(realmUrl, AccessLevel.None)); }); }
public void User_OfferPermissions_WhenExpired_ShouldThrow() { SyncTestHelpers.RunRosTestAsync(async() => { var alice = await SyncTestHelpers.GetUserAsync(); var realmUrl = SyncTestHelpers.RealmUri($"{alice.Identity}/testPermission").AbsoluteUri; await EnsureRealmExists(alice, realmUrl); await TestHelpers.AssertThrows <ArgumentException>(() => alice.OfferPermissionsAsync(realmUrl, AccessLevel.Write, DateTimeOffset.UtcNow.AddDays(-1))); }); }
public void User_AcceptPermissionOffer_WhenTokenIsInvalid_ShouldGetError() { SyncTestHelpers.RunRosTestAsync(async() => { var user = await SyncTestHelpers.GetUserAsync(); await TestHelpers.AssertThrows <HttpException>(() => user.AcceptPermissionOfferAsync("some string"), ex => { Assert.That(ex.ErrorCode, Is.EqualTo(ErrorCode.InvalidParameters)); }); }); }
public void TrustedCA_WhenFileDoesntExist_Throws() { SyncTestHelpers.RunRosTestAsync(async() => { var user = await SyncTestHelpers.GetUserAsync(); var config = new FullSyncConfiguration(SyncTestHelpers.RealmUri("~/TrustedCA_WhenFileDoesntExist_Throws"), user) { TrustedCAPath = "something.pem" }; Assert.That(() => GetRealm(config), Throws.TypeOf <FileNotFoundException>()); }); }
public void User_ApplyPermissions_WithEmail_GrantsAndRevokesPermissions() { SyncTestHelpers.RunRosTestAsync(async() => { var alice = await SyncTestHelpers.GetUserAsync(); var bobEmail = $"{Guid.NewGuid()}@foo.bar"; var bobCredentials = Credentials.UsernamePassword(bobEmail, "a", createUser: true); var bob = await User.LoginAsync(bobCredentials, SyncTestHelpers.AuthServerUri); await TestApplyPermissions(alice, bob, PermissionCondition.Email(bobEmail)).Timeout(20000); }); }
public void Test_RealmUpdate() { SyncTestHelpers.RunRosTestAsync(async() => { var userA = await SyncTestHelpers.GetUserAsync(); var userB = await SyncTestHelpers.GetUserAsync(); var realmUri = await CreateRealm(r => { CreatePermissions(RealmPermission.Get(r).Permissions); var reader = PermissionRole.Get(r, "reader"); reader.Users.Add(userA); reader.Users.Add(userB); var writer = PermissionRole.Get(r, "writer"); writer.Users.Add(userA); }); using (var realm = GetRealm(userA, realmUri)) { var subscription = await SubscribeToObjectsAsync(realm); AssertRealmPrivileges(realm, RealmPrivileges.Read | RealmPrivileges.Update); AssertClassPrivileges(realm, ClassPrivileges.Read | ClassPrivileges.Subscribe | ClassPrivileges.Create | ClassPrivileges.SetPermissions | ClassPrivileges.Update); AssertObjectPrivileges(realm, ObjectPrivileges.Read | ObjectPrivileges.Delete | ObjectPrivileges.SetPermissions | ObjectPrivileges.Update); Assert.That(subscription.Results.Count(), Is.EqualTo(3)); AddObjectsToRealm(realm, new[] { 4, 5, 6 }); Assert.That(subscription.Results.Count(), Is.EqualTo(6)); await SyncTestHelpers.WaitForSyncAsync(realm); Assert.That(subscription.Results.Count(), Is.EqualTo(6)); } using (var realm = GetRealm(userB, realmUri)) { var subscription = await SubscribeToObjectsAsync(realm); AssertRealmPrivileges(realm, RealmPrivileges.Read); AssertClassPrivileges(realm, ClassPrivileges.Read | ClassPrivileges.Subscribe); AssertObjectPrivileges(realm, ObjectPrivileges.Read); Assert.That(subscription.Results.Count(), Is.EqualTo(6)); AddObjectsToRealm(realm, new[] { 7, 8, 9 }); Assert.That(subscription.Results.Count(), Is.EqualTo(9)); await SyncTestHelpers.WaitForSyncAsync(realm); Assert.That(subscription.Results.Count(), Is.EqualTo(6)); } }); }
public void UserLogin_WhenNicknameAfterLogout_LogsSameUserIn() { SyncTestHelpers.RunRosTestAsync(async() => { var nickname = Guid.NewGuid().ToString(); var first = await User.LoginAsync(Credentials.Nickname(nickname), SyncTestHelpers.AuthServerUri); await first.LogOutAsync(); var second = await User.LoginAsync(Credentials.Nickname(nickname), SyncTestHelpers.AuthServerUri); Assert.That(first.Identity, Is.EqualTo(second.Identity)); }); }
public void Subcribe_WaitForSynchronization_Multiple(bool openAsync) { SyncTestHelpers.RunRosTestAsync(async() => { using (var realm = await GetQueryBasedRealm(openAsync)) { var subscription = realm.All <ObjectA>().Where(f => f.IntValue > 0).Subscribe(); await subscription.WaitForSynchronizationAsync().Timeout(5000); var subscription2 = realm.All <ObjectA>().Where(f => f.IntValue > 0).Subscribe(); await subscription2.WaitForSynchronizationAsync().Timeout(5000); } }); }
public void UserChangePasswordTest() { SyncTestHelpers.RunRosTestAsync(async() => { var userId = Guid.NewGuid().ToString(); var credentials = Credentials.UsernamePassword(userId, OriginalPassword, createUser: true); var user = await User.LoginAsync(credentials, SyncTestHelpers.AuthServerUri); await user.ChangePasswordAsync(NewPassword); await user.LogOutAsync(); Assert.That(async() => await user.ChangePasswordAsync("c"), Throws.TypeOf <InvalidOperationException>()); await TestNewPassword(userId); }); }
public void UserLogin_WhenAnonymous_AfterLogoutShouldLoginDifferentUser() { SyncTestHelpers.RunRosTestAsync(async() => { // Login an anonymous user var first = await User.LoginAsync(Credentials.Anonymous(), SyncTestHelpers.AuthServerUri); await first.LogOutAsync(); // Login a second anonymous user var second = await User.LoginAsync(Credentials.Anonymous(), SyncTestHelpers.AuthServerUri); // Expect that the anonymous users to be different Assert.That(first.Identity, Is.Not.EqualTo(second.Identity)); Assert.That(User.AllLoggedIn.Length, Is.EqualTo(1)); }); }