public void SubscribeForObjects_WhenTwoQueriesOverlap_SynchronizesTheUnion() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(async() => { using (var realm = await GetPartialRealm()) { await GetSession(realm).WaitForDownloadAsync(); Assert.That(realm.All <ObjectB>().Count(), Is.EqualTo(0)); Assert.That(realm.All <ObjectA>().Count(), Is.EqualTo(0)); var youngerThan3 = await realm.SubscribeToObjectsAsync <ObjectA>("IntValue < 3").Timeout(2000); var range1to6 = await realm.SubscribeToObjectsAsync <ObjectA>("IntValue > 1 AND IntValue < 6").Timeout(2000); 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 SubscribeForObjects_SynchronizesOnlyMatchingObjects() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(async() => { using (var realm = await GetPartialRealm()) { await GetSession(realm).WaitForDownloadAsync(); Assert.That(realm.All <ObjectB>().Count(), Is.EqualTo(0)); Assert.That(realm.All <ObjectA>().Count(), Is.EqualTo(0)); await realm.SubscribeToObjectsAsync <ObjectA>("IntValue < 5").Timeout(2000); var queriedObjectAs = realm.All <ObjectA>().Where(o => o.IntValue < 5); Assert.That(queriedObjectAs.Count(), Is.EqualTo(5)); foreach (var a in queriedObjectAs) { Assert.That(a.IntValue < 5); Assert.That(a.B, Is.Not.Null); Assert.That(a.B.BoolValue, Is.EqualTo(a.IntValue % 2 == 0)); } } }); }
public void SubscribeForObjects_ReturnsExpectedQuery() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(async() => { using (var realm = await GetPartialRealm()) { await GetSession(realm).WaitForDownloadAsync(); Assert.That(realm.All <ObjectA>().Count(), Is.EqualTo(0)); Assert.That(realm.All <ObjectB>().Count(), Is.EqualTo(0)); var objectAs = await realm.SubscribeToObjectsAsync <ObjectA>("IntValue < 5").Timeout(2000); Assert.That(objectAs.Count(), Is.EqualTo(5)); foreach (var a in objectAs) { Assert.That(a.IntValue < 5); Assert.That(a.B, Is.Not.Null); Assert.That(a.B.BoolValue, Is.EqualTo(a.IntValue % 2 == 0)); } } }); }
public void GetInstanceAsync_ShouldDownloadRealm(bool singleTransaction) { SyncTestHelpers.RequiresRos(); AsyncContext.Run(async() => { var user = await SyncTestHelpers.GetUserAsync(); var realmUri = SyncTestHelpers.RealmUri("~/GetInstanceAsync_ShouldDownloadRealm"); var config = new FullSyncConfiguration(realmUri, user, Guid.NewGuid().ToString()); var asyncConfig = new FullSyncConfiguration(realmUri, user, config.DatabasePath + "_async"); using (var realm = GetRealm(config)) { AddDummyData(realm, singleTransaction); await GetSession(realm).WaitForUploadAsync(); } using (var asyncRealm = await GetRealmAsync(asyncConfig)) { Assert.That(asyncRealm.All <IntPrimaryKeyWithValueObject>().Count(), Is.EqualTo(500)); } }); }
public void SyncConfiguration_LoggerFactory_Test(LogLevel logLevel) { SyncTestHelpers.RequiresRos(); AsyncContext.Run(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 GetSession(realm).WaitForUploadAsync(); } var log = logBuilder.ToString(); Assert.That(log, Does.Contain($"[{logLevel}]")); Assert.That(log, Does.Not.Contain($"[{(logLevel - 1)}]")); }); }
public void PermissionResponse_WhenOfferIsValid_ShouldSetRealmUrl() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(async () => { var alice = await SyncTestHelpers.GetUserAsync(); var bob = await SyncTestHelpers.GetUserAsync(); // Opening a synced realm with just read permission fails. // OS issue: https://github.com/realm/realm-object-store/issues/312 var realmUrl = await GrantPermissions(alice, bob); var syncConfig = new SyncConfiguration(bob, new Uri(realmUrl), Guid.NewGuid().ToString()); Assert.That(() => GetRealm(syncConfig), Throws.Nothing); var handler = new EventHandler<ErrorEventArgs>((sender, e) => { Assert.Fail("Opening the realm should not cause an error.", e.Exception); }); Session.Error += handler; await Task.Delay(2000); Session.Error -= handler; }); }
public void Test_ObjectDelete() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(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 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 WaitForSyncAsync(realmA); await 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); } }); }
private async Task <Realm> GetPartialRealm(Action <SyncConfiguration> setupConfig = null, [CallerMemberName] string realmPath = null) { SyncTestHelpers.RequiresRos(); var user = await SyncTestHelpers.GetUserAsync(); var config = new SyncConfiguration(user, SyncTestHelpers.RealmUri($"~/{realmPath}"), Guid.NewGuid().ToString()) { ObjectClasses = new[] { typeof(ObjectA), typeof(ObjectB) }, IsPartial = true }; setupConfig?.Invoke(config); using (var original = GetRealm(config)) { original.Write(() => { for (var i = 0; i < 10; i++) { original.Add(new ObjectA { StringValue = "A #" + i, IntValue = i, B = new ObjectB { StringValue = "B #" + i, BoolValue = i % 2 == 0, } }); } }); await GetSession(original).WaitForUploadAsync(); } try { Realm.DeleteRealm(config); } catch { } config = new SyncConfiguration(config.User, config.ServerUri, config.DatabasePath + "_partial") { ObjectClasses = config.ObjectClasses, IsPartial = true }; var result = GetRealm(config); await GetSession(result).WaitForDownloadAsync(); Assert.That(result.All <ObjectB>().Count(), Is.EqualTo(0)); Assert.That(result.All <ObjectA>().Count(), Is.EqualTo(0)); return(result); }
public void Test_ClassUpdate() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(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 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 WaitForSyncAsync(realm); // Change is reverted Assert.That(obj.StringValue, Is.EqualTo("New value")); } }); }
public void EnableSSLValidation_WhenFalse_ValidatesCorrectly(bool openAsync) { SyncTestHelpers.RequiresRos(); TestSSLCore(config => { config.EnableSSLValidation = false; }, openAsync); }
public void TrustedCA_WhenProvided_ValidatesCorrectly(bool openAsync) { SyncTestHelpers.RequiresRos(); TestSSLCore(config => { config.TrustedCAPath = TestHelpers.CopyBundledDatabaseToDocuments("trusted_ca.pem", "trusted_ca.pem"); }, openAsync); }
public void Test_RealmUpdate() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(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 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 WaitForSyncAsync(realm); Assert.That(subscription.Results.Count(), Is.EqualTo(6)); } }); }
public void Test_ObjectUpdate() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(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 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 WaitForSyncAsync(realm); Assert.That(obj1.StringValue, Is.EqualTo("New value")); } }); }
public void PermissionChange_IsProcessedByServer() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(async () => { var user = await SyncTestHelpers.GetUserAsync(); var permissionChange = await CreateChange(user, "*"); Assert.That(permissionChange.Status, Is.EqualTo(ManagementObjectStatus.Success)); }); }
public void User_ApplyPermissions_WithUserId_GrantsAndRevokesPermissions() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(async () => { var alice = await SyncTestHelpers.GetUserAsync(); var bob = await SyncTestHelpers.GetUserAsync(); await TestApplyPermissions(alice, bob, PermissionCondition.UserId(bob.Identity)).Timeout(1000000); }); }
public void UserLookup_WhenTargetUserDoesNotExist_ShouldReturnNull() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(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 PermissionOffer_WhenValid_TokenIsSet() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(async () => { var user = await SyncTestHelpers.GetUserAsync(); var permissionOffer = await CreateOffer(user); Assert.That(permissionOffer.Status, Is.EqualTo(ManagementObjectStatus.Success)); Assert.That(permissionOffer.Token, Is.Not.Null); }); }
public void UserLogin_WhenAnonymousAndDifferentCredentials_ShouldLoginDifferentUser() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(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 PermissionResponse_WhenTokenIsInvalid_ShouldGetError() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(async () => { var user = await SyncTestHelpers.GetUserAsync(); var permissionResponse = await CreateResponse(user, "Some string"); Assert.That(permissionResponse.Status, Is.EqualTo(ManagementObjectStatus.Error)); Assert.That(permissionResponse.ErrorCode, Is.EqualTo(ErrorCode.InvalidParameters)); Assert.That(permissionResponse.StatusMessage, Is.Not.Null); }); }
public void UserLogin_WhenNickname_LogsUserIn() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(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.RequiresRos(); AsyncContext.Run(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 User_ApplyPermissions_WithEmail_GrantsAndRevokesPermissions() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(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(10000); }); }
public void TrustedCA_WhenFileDoesntExist_Throws() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(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 Permission_ValidateWrite() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(async () => { var alice = await SyncTestHelpers.GetUserAsync(); var bob = await SyncTestHelpers.GetUserAsync(); var realmUrl = await GrantPermissions(alice, bob); await ValidateWriteAndSync(realmUrl, alice, bob, 1, 2); }); }
public void PermissionOffer_WhenExpired_ShouldGetError() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(async () => { var user = await SyncTestHelpers.GetUserAsync(); var permissionOffer = await CreateOffer(user, expiresAt: DateTimeOffset.UtcNow.AddDays(-1)); Assert.That(permissionOffer.Status, Is.EqualTo(ManagementObjectStatus.Error)); Assert.That(permissionOffer.Token, Is.Null); Assert.That(permissionOffer.ErrorCode, Is.EqualTo(ErrorCode.ExpiredPermissionOffer)); Assert.That(permissionOffer.StatusMessage, Is.Not.Null); }); }
public void User_OfferPermissions_WhenNoAccess_ShouldThrow() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(async () => { var alice = await SyncTestHelpers.GetUserAsync(); var realmUrl = SyncTestHelpers.RealmUri($"{alice.Identity}/testPermission").AbsoluteUri; EnsureRealmExists(alice, realmUrl); await AssertThrows<ArgumentException>(() => alice.OfferPermissionsAsync(realmUrl, AccessLevel.None)); }); }
public void User_AcceptPermissionOffer_WhenTokenIsInvalid_ShouldGetError() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(async () => { var user = await SyncTestHelpers.GetUserAsync(); await AssertThrows<PermissionException>(() => user.AcceptPermissionOfferAsync("some string"), ex => { Assert.That(ex.ErrorCode, Is.EqualTo(ErrorCode.InvalidParameters)); }); }); }
public void UserLogin_WhenNicknameAfterLogout_LogsSameUserIn() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(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 Test_RealmRead() { SyncTestHelpers.RequiresRos(); AsyncContext.Run(async() => { var userA = await SyncTestHelpers.GetUserAsync(); var userB = await SyncTestHelpers.GetUserAsync(); var realmUri = await CreateRealm(r => { CreatePermissions(RealmPermission.Get(r).Permissions); var role = PermissionRole.Get(r, "reader"); role.Users.Add(userA); }); using (var realm = GetRealm(userA, realmUri)) { var query = realm.All <ObjectWithPermissions>(); var subscription = query.Subscribe(); await subscription.WaitForSynchronizationAsync().Timeout(2000); AssertRealmPrivileges(realm, RealmPrivileges.Read); AssertClassPrivileges(realm, ClassPrivileges.Read | ClassPrivileges.Subscribe); AssertObjectPrivileges(realm, ObjectPrivileges.Read); Assert.That(subscription.Results.Count(), Is.EqualTo(3)); AddObjectsToRealm(realm, new[] { 4, 5, 6 }); Assert.That(subscription.Results.Count(), Is.EqualTo(6)); await WaitForSyncAsync(realm); Assert.That(subscription.Results.Count(), Is.EqualTo(3)); } using (var realm = GetRealm(userB, realmUri)) { var query = realm.All <ObjectWithPermissions>(); var subscription = query.Subscribe(); await subscription.WaitForSynchronizationAsync().Timeout(2000); AssertRealmPrivileges(realm, 0); AssertClassPrivileges(realm, 0); Assert.That(subscription.Results.Count(), Is.Zero); } }); }
public void GetInstanceAsync_OpensReadonlyRealm(bool singleTransaction) { SyncTestHelpers.RequiresRos(); AsyncContext.Run(async() => { var alice = await SyncTestHelpers.GetUserAsync(); var bob = await SyncTestHelpers.GetUserAsync(); var realmUri = SyncTestHelpers.RealmUri($"{alice.Identity}/GetInstanceAsync_OpensReadonlyRealm"); var aliceConfig = new FullSyncConfiguration(realmUri, alice, Guid.NewGuid().ToString()); var aliceRealm = GetRealm(aliceConfig); await alice.ApplyPermissionsAsync(PermissionCondition.UserId(bob.Identity), realmUri.AbsoluteUri, AccessLevel.Read).Timeout(1000); AddDummyData(aliceRealm, singleTransaction); var bobConfig = new FullSyncConfiguration(realmUri, bob, Guid.NewGuid().ToString()); var bobRealm = await GetRealmAsync(bobConfig); var bobsObjects = bobRealm.All <IntPrimaryKeyWithValueObject>(); var alicesObjects = aliceRealm.All <IntPrimaryKeyWithValueObject>(); Assert.That(bobsObjects.Count(), Is.EqualTo(alicesObjects.Count())); var bobTcs = new TaskCompletionSource <object>(); bobsObjects.AsRealmCollection().CollectionChanged += (sender, e) => { bobTcs.TrySetResult(null); }; aliceRealm.Write(() => { aliceRealm.Add(new IntPrimaryKeyWithValueObject { Id = 9999, StringValue = "Some value" }); }); await bobTcs.Task.Timeout(1000); Assert.That(bobsObjects.Count(), Is.EqualTo(alicesObjects.Count())); var bobObject = bobRealm.Find <IntPrimaryKeyWithValueObject>(9999); Assert.That(bobObject, Is.Not.Null); Assert.That(bobObject.StringValue, Is.EqualTo("Some value")); }); }