public override async Task <bool> Handle() { if (MainObject.Type != "https://www.w3.org/ns/activitystreams#Like") { return(true); } var userData = Actor.Data; string targetCollectionId = null; targetCollectionId = userData["liked"].SingleOrDefault()?.Id; if (targetCollectionId == null) { return(true); } var targetCollection = await EntityStore.GetEntity(targetCollectionId, false); var objectEntity = await EntityStore.GetEntity(MainObject.Data["object"].Single().Id, true); if (objectEntity == null) { throw new InvalidOperationException($"Cannot {MainObject.Type.ToLower()} a non-existant object!"); } await _collection.AddToCollection(targetCollection, objectEntity); return(true); }
public void Delete(ModelViewModel viewModel) { Model toRemove = EntityStore.Models.Find(viewModel.Id); EntityStore.Models.Remove(toRemove); EntityStore.SaveChanges(); }
public ContactsEndpoint(EntityStore<ContactEntity, int> contacts) : base("/contacts") { Get["/"] = parameters => { string token = Request.Query.token; if (token.ToNullableGuid() != FakeyAuth.Token) { return new Response() { StatusCode = HttpStatusCode.Forbidden }; } return contacts.GetAll(); }; Post["/"] = parameters => { var contact = this.Bind<ContactEntity>(); contact.Created = DateTime.UtcNow; ValidationUtil.AssertIsValid(contact); contacts.Save(contact); return contact; }; }
public void WhereClauseWithGetDatePartWeekDay() { var store = new EntityStore(_dbConnection); var singleEmployee = store.GetSingle <Employee>(e => SqlFunctions.GetWeekday(e.Birthdate) >= 2); Xunit.Assert.NotNull(singleEmployee); }
public void WhereClauseWithGetDatePartMillisecond() { var store = new EntityStore(_dbConnection); var singleEmployee = store.GetSingle <Order>(o => SqlFunctions.GetMillisecond(o.OrderDate) >= 0); Xunit.Assert.NotNull(singleEmployee); }
public void WhereClauseWithGetDatePartYear() { var store = new EntityStore(_dbConnection); var singleEmployee = store.GetSingle <Employee>(e => SqlFunctions.GetYear(e.Birthdate) <= DateTime.Now.Year); Xunit.Assert.NotNull(singleEmployee); }
public void WhereClauseWithGetDatePartDayOfYear1() { var store = new EntityStore(_dbConnection); var order = store.GetSingle <Order>(o => SqlFunctions.GetDayOfYear(o.OrderDate) <= DateTime.Now.DayOfYear); Xunit.Assert.NotNull(order); }
public void WhereClauseWithAddWeeks() { var store = new EntityStore(_dbConnection); var singleEmployee = store.GetSingle <Employee>(e => SqlFunctions.AddWeeks(e.Birthdate, -3) >= DateTime.Now.AddMonths(-90 * 12)); Xunit.Assert.NotNull(singleEmployee); }
public void WhereClauseWithAddMilliseconds() { var store = new EntityStore(_dbConnection); var singleEmployee = store.GetSingle <Order>(o => SqlFunctions.AddMilliseconds(o.OrderDate, 30000) >= DateTime.Now.AddMonths(-90 * 12)); Xunit.Assert.NotNull(singleEmployee); }
public void SeletTop2() { var store = new EntityStore(_dbConnection); int skip = 10, take = 10; var sortOrder = new List <SortOrderField> { new SortOrderField(typeof(Employee), "LastName"), new SortOrderField(typeof(Employee), "FirstName"), new SortOrderField(typeof(Employee), "City", SortOrder.Descending) }; var selectQuery = store.GetSelectQuery <Employee>() .GetTopRows(skip + take) .Where(e => e.Id > 1) .OrderBy(sortOrder); var employeeSet = store.ExecuteQuery(selectQuery); Xunit.Assert.NotNull(employeeSet); var returnSet = employeeSet.Skip(skip).Take(take); Xunit.Assert.NotNull(returnSet); Xunit.Assert.True(returnSet.Count() == take); }
public void WhereClauseWithAddMinutes() { var store = new EntityStore(_dbConnection); var singleEmployee = store.GetSingle <Order>(o => SqlFunctions.AddMinutes(o.OrderDate, -3) >= DateTime.Now.AddMinutes(-90 * 12 * 30 * 24 * 60)); Xunit.Assert.NotNull(singleEmployee); }
public void SelectByKey() { var store = new EntityStore(_dbConnection); var SteveEmployeeId = 1; var employee = store.GetByKey <Employee>(1); var employee1 = store.GetByKey <Employee>(new { Id = 1 }); var employee2 = store.GetByKey <Employee>(new Employee { Id = 1, FirstName = "Steve", LastName = "Rogers" }); var employee3 = store.GetByKey <Employee>(SteveEmployeeId); var order = store.GetByKey <Order>(1); var order1 = store.GetByKey <Order>(new { Id = 1 }); Xunit.Assert.NotNull(employee); Xunit.Assert.NotNull(employee1); Xunit.Assert.NotNull(employee2); Xunit.Assert.NotNull(employee3); Xunit.Assert.True(employee.Id == 1); Xunit.Assert.True(employee1.Id == 1); Xunit.Assert.True(employee2.Id == 1); Xunit.Assert.True(employee3.Id == 1); Xunit.Assert.NotNull(order); Xunit.Assert.NotNull(order1); Xunit.Assert.True(order.Id == 1); Xunit.Assert.True(order1.Id == 1); }
//public static async AsyncReply<T> CreateResourceAsync<T>(this IServiceProvider serviceProvider, T properties = null) where T : class, IResource //{ // var options = serviceProvider.GetService<IDbContextOptions>().FindExtension<EsiurExtensionOptions<T>>(); // var resource = await Warehouse.New<T>("", options.Store, null, null, null, properties); // resource.Instance.Managers.AddRange(options.Store.Instance.Managers.ToArray()); // return resource; //} //public static T CreateResource<T>(this IServiceProvider serviceProvider, object properties = null) where T : class, IResource // => CreateResourceAsync<T>(serviceProvider, properties).Wait(); public static DbContextOptionsBuilder UseEsiur(this DbContextOptionsBuilder optionsBuilder, EntityStore store, Func <DbContext> getter = null //IServiceCollection services = null //string name = null, //IResource parent = null, //IPermissionsManager manager = null, //Func<DbContext> dbContextProvider = null ) { var extension = optionsBuilder.Options.FindExtension <EsiurExtensionOptions>(); if (extension == null) { if (store == null) { return(optionsBuilder); } store.Options = optionsBuilder.Options; extension = new EsiurExtensionOptions(store); } ((IDbContextOptionsBuilderInfrastructure)optionsBuilder).AddOrUpdateExtension(extension); return(optionsBuilder); }
public override async Task <bool> Handle() { if (MainObject.Type != "https://www.w3.org/ns/activitystreams#Delete") { return(true); } var oldObject = await EntityStore.GetEntity(MainObject.Data["object"].Single().Id, true); var newData = oldObject.Data; foreach (var kv in newData) { if (!DeleteWhitelist.Contains(kv.Key)) { kv.Value.Clear(); } } newData.Type.Clear(); newData.Type.Add("https://www.w3.org/ns/activitystreams#Tombstone"); newData.Replace("deleted", ASTerm.MakePrimitive(DateTime.Now.ToString("o"))); var newObject = APEntity.From(newData); await EntityStore.StoreEntity(newObject); return(true); }
public override async Task <bool> Handle() { if (MainObject.Type != "Like" && MainObject.Type != "Follow") { return(true); } var userData = Actor.Data; string targetCollectionId = null; if (MainObject.Type == "Like") { targetCollectionId = (string)userData["likes"].Single().Primitive; } else if (MainObject.Type == "Follow") { targetCollectionId = (string)userData["following"].Single().Primitive; } var targetCollection = await EntityStore.GetEntity(targetCollectionId, false); var objectEntity = await EntityStore.GetEntity((string)MainObject.Data["object"].Single().Primitive, true); if (objectEntity == null) { throw new InvalidOperationException($"Cannot {MainObject.Type.ToLower()} a non-existant object!"); } await _collection.AddToCollection(targetCollection, objectEntity); return(true); }
public Bootstrap(IDbConnection dbConnection) { lock (_lockObject) { if (!EntityMapper.Entities.Keys.Any()) { var assembliesOfModelTypes = new[] { Assembly.Load("FluentSql.Tests") }; var store = new EntityStore(dbConnection); var fluentTestDb = new Database { Name = TestConstants.TestDatabaseName, TableNamesInPlural = true, NameSpace = "FluentSql.Tests.Models" }; var sqlGenerator = new SqlServerSqlGenerator(includeDbNameInQuery: true); var databases = new List <Database> { fluentTestDb }; store.ExecuteScript(SqlScripts.CREATE_DATABASE, null, false, CommandType.Text); store.ExecuteScript(SqlScripts.CREATE_TABLES, null, false, CommandType.Text); new EntityMapper(dbConnection, databases, assembliesOfModelTypes, null, onPostEntityMapping, null); } } }
public virtual EntityStore UpdateEntityStore(EntityStore entity) { if (entity.IsTransient()) { return(entity); } EntityStore other = GetEntityStore(entity.StoreId); if (entity.Equals(other)) { return(entity); } string sql = @"Update EntityStore set [ID]=@ID , [EntityID]=@EntityID , [EntityType]=@EntityType , [CreatedOn]=@CreatedOn where StoreID=@StoreID" ; SqlParameter[] parameterArray = new SqlParameter[] { new SqlParameter("@StoreID", entity.StoreId) , new SqlParameter("@ID", entity.Id) , new SqlParameter("@EntityID", entity.EntityId) , new SqlParameter("@EntityType", entity.EntityType) , new SqlParameter("@CreatedOn", entity.CreatedOn) }; SqlHelper.ExecuteNonQuery(this.ConnectionString, CommandType.Text, sql, parameterArray); return(GetEntityStore(entity.StoreId)); }
public override async Task <bool> Handle() { if (_entityData.IsActivity(MainObject.Data)) { return(true); } var data = MainObject.Data; var createActivity = new ASObject(); createActivity["type"].Add(new ASTerm("Create")); createActivity["to"].AddRange(data["to"]); createActivity["bto"].AddRange(data["bto"]); createActivity["cc"].AddRange(data["cc"]); createActivity["bcc"].AddRange(data["bcc"]); createActivity["audience"].AddRange(data["audience"]); createActivity["actor"].Add(new ASTerm(Actor.Id)); createActivity["object"].Add(new ASTerm(MainObject.Id)); createActivity["id"].Add(new ASTerm(await _entityData.FindUnusedID(EntityStore, createActivity))); var activityEntity = await EntityStore.StoreEntity(APEntity.From(createActivity, true)); MainObject = activityEntity; return(true); }
async Task <IEntityStore <string, TwinStoreEntity> > GetTwinStore(IComponentContext context) { string entityName = "EdgeTwin"; Option <IEntityStore <string, TwinStoreEntity> > twinStoreOption = Option.None <IEntityStore <string, TwinStoreEntity> >(); var storeProvider = await context.Resolve <Task <IStoreProvider> >(); if (this.encryptTwinStore) { Option <IEncryptionProvider> encryptionProvider = await context.Resolve <Task <Option <IEncryptionProvider> > >(); twinStoreOption = encryptionProvider.Map( e => { IEntityStore <string, string> underlyingEntityStore = storeProvider.GetEntityStore <string, string>($"underlying{entityName}"); IKeyValueStore <string, string> es = new UpdatableEncryptedStore <string, string>(underlyingEntityStore, e); ITypeMapper <string, string> keyMapper = new JsonMapper <string>(); ITypeMapper <TwinStoreEntity, string> valueMapper = new JsonMapper <TwinStoreEntity>(); IKeyValueStore <string, TwinStoreEntity> dbStoreMapper = new KeyValueStoreMapper <string, string, TwinStoreEntity, string>(es, keyMapper, valueMapper); IEntityStore <string, TwinStoreEntity> tes = new EntityStore <string, TwinStoreEntity>(dbStoreMapper, entityName); return(tes); }); } IEntityStore <string, TwinStoreEntity> twinStore = twinStoreOption.GetOrElse( () => storeProvider.GetEntityStore <string, TwinStoreEntity>(entityName)); return(twinStore); }
public virtual EntityStore InsertEntityStore(EntityStore entity) { EntityStore other = new EntityStore(); other = entity; if (entity.IsTransient()) { string sql = @"Insert into EntityStore ( [StoreID] ,[ID] ,[EntityID] ,[EntityType] ,[CreatedOn] ) Values ( @StoreID , @ID , @EntityID , @EntityType , @CreatedOn ); Select scope_identity()" ; SqlParameter[] parameterArray = new SqlParameter[] { new SqlParameter("@StoreID", entity.StoreId) , new SqlParameter("@ID", entity.Id) , new SqlParameter("@EntityID", entity.EntityId) , new SqlParameter("@EntityType", entity.EntityType) , new SqlParameter("@CreatedOn", entity.CreatedOn) }; var identity = SqlHelper.ExecuteScalar(this.ConnectionString, CommandType.Text, sql, parameterArray); if (identity == DBNull.Value) { throw new DataException("Identity column was null as a result of the insert operation."); } return(GetEntityStore(Convert.ToInt32(identity))); } return(entity); }
public void TestInitialize() { this.serializerMock = new Mock <ISerializer>(); this.savedDataHandlerMock = new Mock <ISavedDataHandler>(); this.entityUpdateSubCenterMock = new Mock <IEntityUpdateSubscriptionCenter <IIdEntity <string>, string> >(); this.storeUnderTest = new EntityStore <IIdEntity <string>, string>(this.serializerMock.Object, this.savedDataHandlerMock.Object, this.entityUpdateSubCenterMock.Object); }
public override async Task <bool> Handle() { if (MainObject.Type != "https://www.w3.org/ns/activitystreams#Block") { return(true); } var activityData = MainObject.Data; var toBlock = activityData["object"].First().Id; var entity = await EntityStore.GetEntity(toBlock, true); if (entity == null) { throw new InvalidOperationException("Cannot block a non-existant object"); } var blockscollection = await EntityStore.GetEntity(Actor.Data["blocks"].First().Id, false); await _collection.AddToCollection(blockscollection, MainObject); var blockedcollection = await EntityStore.GetEntity(blockscollection.Data["blocked"].First().Id, false); await _collection.AddToCollection(blockedcollection, entity); return(true); }
public async Task GetServiceIdentityFromServiceTest() { // Arrange var store = new EntityStore <string, string>(new InMemoryDbStore(), "cache"); var serviceAuthenticationNone = new ServiceAuthentication(ServiceAuthenticationType.None); var serviceAuthenticationSas = new ServiceAuthentication(new SymmetricKeyAuthentication(GetKey(), GetKey())); var si_device = new ServiceIdentity("d2", "1234", Enumerable.Empty <string>(), serviceAuthenticationNone, ServiceIdentityStatus.Enabled); var si_module = new ServiceIdentity("d1", "m1", "1234", Enumerable.Empty <string>(), serviceAuthenticationSas, ServiceIdentityStatus.Disabled); var serviceProxy = new Mock <IServiceProxy>(); serviceProxy.Setup(s => s.GetServiceIdentity("d2")).ReturnsAsync(Option.Some(si_device)); serviceProxy.Setup(s => s.GetServiceIdentity("d1", "m1")).ReturnsAsync(Option.Some(si_module)); DeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await DeviceScopeIdentitiesCache.Create(serviceProxy.Object, store, TimeSpan.FromHours(1)); // Act Option <ServiceIdentity> deviceServiceIdentity = await deviceScopeIdentitiesCache.GetServiceIdentityFromService("d2"); Option <ServiceIdentity> moduleServiceIdentity = await deviceScopeIdentitiesCache.GetServiceIdentityFromService("d1/m1"); // Assert Assert.True(deviceServiceIdentity.HasValue); Assert.True(si_device.Equals(deviceServiceIdentity.OrDefault())); Assert.True(moduleServiceIdentity.HasValue); Assert.True(si_module.Equals(moduleServiceIdentity.OrDefault())); }
public override async Task <bool> Handle() { if (MainObject.Type != "https://www.w3.org/ns/activitystreams#Accept" && MainObject.Type != "https://www.w3.org/ns/activitystreams#Reject") { return(true); } var subObject = await EntityStore.GetEntity(MainObject.Data["object"].Single().Id, true); var requestedUser = await EntityStore.GetEntity(subObject.Data["actor"].First().Id, true); if (subObject.Type != "https://www.w3.org/ns/activitystreams#Follow") { return(true); } if (subObject.Data["object"].Single().Id != Actor.Id) { return(true); } bool isAccept = MainObject.Type == "https://www.w3.org/ns/activitystreams#Accept"; var followers = await EntityStore.GetEntity(Actor.Data["followers"].Single().Id, false); if (isAccept && !await _collection.Contains(followers, requestedUser.Id)) { await _collection.AddToCollection(followers, requestedUser); } if (!isAccept && await _collection.Contains(followers, requestedUser.Id)) { await _collection.RemoveFromCollection(followers, requestedUser); } return(true); }
public void Post(ModelDetailsViewModel model) { if (model.Id == 0) { AddNewModel(model); } else { UpdateExistingModel(model); } try { EntityStore.SaveChanges(); } catch (DbEntityValidationException ex) { StringBuilder sb = new StringBuilder(); foreach (DbEntityValidationResult validationErrors in ex.EntityValidationErrors) { foreach (DbValidationError validationError in validationErrors.ValidationErrors) { sb.Append(string.Format("{0} - {1}", validationError.PropertyName, validationError.ErrorMessage)); } } throw new Exception(sb.ToString()); } }
public override async Task <bool> Handle() { if (_entityData.IsActivity(MainObject.Data)) { return(true); } var data = MainObject.Data; var createActivity = new ASObject(); createActivity.Type.Add("https://www.w3.org/ns/activitystreams#Create"); createActivity["to"].AddRange(data["to"]); createActivity["bto"].AddRange(data["bto"]); createActivity["cc"].AddRange(data["cc"]); createActivity["bcc"].AddRange(data["bcc"]); createActivity["audience"].AddRange(data["audience"]); createActivity["actor"].Add(ASTerm.MakeId(Actor.Id)); createActivity["object"].Add(ASTerm.MakeId(MainObject.Id)); createActivity.Id = await _entityData.FindUnusedID(EntityStore, createActivity); var activityEntity = await EntityStore.StoreEntity(APEntity.From(createActivity, true)); MainObject = activityEntity; return(true); }
public async Task InitializeFromStoreTest() { // Arrange var iterator = new Mock <IServiceIdentitiesIterator>(); iterator.Setup(i => i.HasNext).Returns(true); iterator.Setup(i => i.GetNext()).ThrowsAsync(new InvalidOperationException("Some error")); var serviceProxy = new Mock <IServiceProxy>(); serviceProxy.Setup(s => s.GetServiceIdentitiesIterator()).Returns(iterator.Object); var store = new EntityStore <string, string>(new InMemoryDbStore(), "cache"); var serviceAuthentication = new ServiceAuthentication(ServiceAuthenticationType.None); var si1 = new ServiceIdentity("d1", "1234", Enumerable.Empty <string>(), serviceAuthentication, ServiceIdentityStatus.Enabled); var si2 = new ServiceIdentity("d2", "m1", "2345", Enumerable.Empty <string>(), serviceAuthentication, ServiceIdentityStatus.Enabled); var storedSi1 = new DeviceScopeIdentitiesCache.StoredServiceIdentity(si1); await store.Put(si1.Id, storedSi1.ToJson()); var storedSi2 = new DeviceScopeIdentitiesCache.StoredServiceIdentity(si2); await store.Put(si2.Id, storedSi2.ToJson()); // Act IDeviceScopeIdentitiesCache deviceScopeIdentitiesCache = await DeviceScopeIdentitiesCache.Create(serviceProxy.Object, store, TimeSpan.FromHours(1)); Option <ServiceIdentity> receivedServiceIdentity1 = await deviceScopeIdentitiesCache.GetServiceIdentity("d1"); Option <ServiceIdentity> receivedServiceIdentity2 = await deviceScopeIdentitiesCache.GetServiceIdentity("d2/m1"); // Assert Assert.True(si1.Equals(receivedServiceIdentity1.OrDefault())); Assert.True(si2.Equals(receivedServiceIdentity2.OrDefault())); }
void Start() { if (!Application.isPlaying) { return; } List <Point3D> blocksToInit; IChunkGenerator generator; string entityID; Setup(out blocksToInit, out generator, out entityID); entityStore = new EntityStore(generator, entityID); chunkStore = new ChunkStore(entityStore, Material, transform); blocksToInit.AddRange(entityStore.GetSavedChunks()); blocksToInit = blocksToInit.Distinct().ToList(); pendingChunks = blocksToInit.Select(chunkPos => new PendingChunk() { ChunkPos = chunkPos, WorldPos = transform.TransformPoint(TransformVertex(new Vector3(chunkPos.x, chunkPos.y, chunkPos.z) * Chunk.BlockSize)) }).ToList(); OnSetupCompleted(); }
public override async Task <bool> Handle() { if (MainObject.Type != "Block") { return(true); } var activityData = MainObject.Data; var toBlock = (string)activityData["object"].First().Primitive; var entity = await EntityStore.GetEntity(toBlock, true); if (entity == null) { throw new InvalidOperationException("Cannot block a non-existant object"); } var blockscollection = await EntityStore.GetEntity((string)Actor.Data["blocks"].First().Primitive, false); await _collection.AddToCollection(blockscollection, MainObject); var blockedcollection = await EntityStore.GetEntity((string)blockscollection.Data["_blocked"].First().Primitive, false); await _collection.AddToCollection(blockedcollection, entity); return(true); }
public static CheckpointStore Create(IDbStoreProvider dbStoreProvider) { IDbStore dbStore = Preconditions.CheckNotNull(dbStoreProvider, nameof(dbStoreProvider)).GetDbStore(Constants.CheckpointStorePartitionKey); IEntityStore <string, CheckpointEntity> underlyingStore = new EntityStore <string, CheckpointEntity>(dbStore, nameof(CheckpointEntity), 12); return(new CheckpointStore(underlyingStore)); }
public void Post(MakeViewModel viewModel) { if (viewModel.Id == 0) { Make make = new Make { Name = viewModel.Name, Location = viewModel.Location, ImageUrl = viewModel.ImageUrl }; EntityStore.Makes.Add(make); } else { Make make = EntityStore.Makes.Find(viewModel.Id); make.Name = viewModel.Name; make.Location = viewModel.Location; make.ImageUrl = viewModel.ImageUrl; } try { EntityStore.SaveChanges(); } catch (DbEntityValidationException ex) { StringBuilder sb = new StringBuilder(); foreach (DbEntityValidationResult validationErrors in ex.EntityValidationErrors) { foreach (DbValidationError validationError in validationErrors.ValidationErrors) { sb.Append(string.Format("{0} - {1}", validationError.PropertyName, validationError.ErrorMessage)); } } throw new Exception(sb.ToString()); } }
public EntityStoreTests() { _simpleType = EntityTypes.Register<TestClass>(); _aliasedType = EntityTypes.Register<AliasedColumnsClass>(et => { et.Alias(t => t.Name, "ADifferentName") .Alias(t => t.Description, null); }); _simpleEntityStore = new EntityStore<TestClass, int>(); _aliasedEntityStore = new EntityStore<AliasedColumnsClass, int>(); }
public void Setup() { Mappings = SetupMappings(); _entityStore = new EntityStore(); _factory = new EntityContextFactory().WithEntitySource(CreateEntitySource) .WithOntology(new DefaultOntologiesProvider()) .WithOntology(new LifeOntology()) .WithOntology(new TestOntologyProvider(IncludeFoaf)) .WithOntology(new ChemOntology()) .WithMappings(BuildMappings) .WithMetaGraphUri(MetaGraphUri) .WithEntityStore(() => _entityStore); ChildSetup(); }
static void Main(string[] args) { if (args.Length != 3) { Console.WriteLine("You need to provide 3 arguments: the login, the emailaddress and the password"); return; } var user = new User(args[0], args[1]); user.SetPassword(args[2]); var entityStore = new EntityStore(new MongoContext()); entityStore.Save(user); }
public SqliteDbAccessTests() { var file = GetDbFile(); if (File.Exists(file)) File.Delete(file); CreateDatabase(); var conn = GetDbConnection(); EntityTypes.Register<Manufacturer>(); EntityTypes.Register<Product>(); _manufacturerStore = new EntityStore<Manufacturer, int>(conn, new SqliteGenerator()); _productStore = new EntityStore<Product, int>(conn, new SqliteGenerator()); }
public void Setup() { _entityStore = new EntityStore(); }
protected CommandTestFixture() { MongoContext = new MongoTestContext(); EntityStore = new EntityStore(MongoContext); }
public void ThrowsOnUnregisteredType() { var ex = Assert.Throws<Exception>(() => { var s = new EntityStore<UnregisteredClass, int>(); }); Assert.Equal("You must register your type with EntityTypes before instantiating an EntityStore.", ex.Message); }