public static IContainer InMemoryStartup() { var presentationdocumentStore = new EmbeddableDocumentStore { RunInMemory = true, }; presentationdocumentStore.Initialize(); ObjectFactory.Initialize(config => { config.Scan(scan => { scan.TheCallingAssembly(); scan.WithDefaultConventions(); }); config.AddRegistry(new CoreRegistry(presentationdocumentStore)); }); ObjectFactory.AssertConfigurationIsValid(); ObjectFactory.WhatDoIHave(); WaitForIndexes(presentationdocumentStore); IndexCreation.CreateIndexes(typeof(Users_ByUsername).Assembly, presentationdocumentStore); WaitForIndexes(presentationdocumentStore); return ObjectFactory.Container; }
public void CanQueryMetadata() { using (var store = new EmbeddableDocumentStore { RunInMemory = true }) { store.Initialize(); using (var s = store.OpenSession()) { s.Store(new User { Metadata = { IsActive = true } }); s.SaveChanges(); } using (var s = store.OpenSession()) { var actual = s.Query<User>() .Customize(x=>x.WaitForNonStaleResultsAsOfLastWrite()) .Where(x => x.Metadata.IsActive == true) .Count(); Assert.Equal(1, actual); } } }
public void DocumentStoreWorksWhenAddingItemThenDeletingItAndThenGrabbingNonExistingItemAndStoringNewOne() { using (var documentStore = new EmbeddableDocumentStore { RunInMemory = true }.Initialize()) { documentStore.Conventions.AllowQueriesOnId = true; using (var session = documentStore.OpenSession()) { var deletedModel = new TestModel { Id = 1 }; session.Store(deletedModel); session.SaveChanges(); session.Delete(deletedModel); session.SaveChanges(); TestModel testModelItem = session.Query<TestModel>().SingleOrDefault(t => t.Id == 2) ?? new TestModel { Id = 2 }; Assert.NotNull(testModelItem); session.Store(testModelItem); session.SaveChanges(); var list = session.Query<TestModel>() .Customize(x => x.WaitForNonStaleResults()) .ToList(); Assert.Equal(1, list.Count()); } } }
/// <summary> /// Configures StructureMap to look for registries. /// </summary> /// <returns></returns> public static IContainer Initialize() { ObjectFactory.Initialize(x => { var documentStore = new EmbeddableDocumentStore { ConnectionStringName = "RavenDB" }; documentStore.Conventions.FindTypeTagName = type => typeof(IPageModel).IsAssignableFrom(type) ? "Pages" : null; documentStore.RegisterListener(new StoreListener()); documentStore.Initialize(); IndexCreation.CreateIndexes(typeof(Documents_ByParent).Assembly, documentStore); x.For<IDocumentStore>().Use(documentStore); x.For<IDocumentSession>() .HybridHttpOrThreadLocalScoped() .Use(y => { var store = y.GetInstance<IDocumentStore>(); return store.OpenSession(); }); x.For<IVirtualPathResolver>().Use<VirtualPathResolver>(); x.For<IPathResolver>().Use<PathResolver>(); x.For<IPathData>().Use<PathData>(); x.For<IControllerMapper>().Use<ControllerMapper>(); x.For<ISettings>().Use<Settings>(); x.Scan(scanner => { scanner.AssembliesFromApplicationBaseDirectory(); scanner.Convention<PageTypeRegistrationConvetion>(); }); x.For<IPageModel>().UseSpecial(y => y.ConstructedBy( r => ((MvcHandler) HttpContext.Current.Handler).RequestContext.RouteData.GetCurrentPage<IPageModel>())); x.For<IStructureInfo>().UseSpecial(y => y.ConstructedBy(r => ((MvcHandler)HttpContext.Current.Handler).RequestContext.RouteData.Values["StructureInfo"] as IStructureInfo)); }); return ObjectFactory.Container; }
public static void Startup() { var sampleFrameworkDb = new EmbeddableDocumentStore { DataDirectory = "App_Data\\RavenDb", UseEmbeddedHttpServer = true }; sampleFrameworkDb.RegisterListener(new DocumentConversionListener()); sampleFrameworkDb.Conventions.FindClrTypeName = FindClrTypeName; sampleFrameworkDb.Conventions.FindTypeTagName = FindTypeTagName; sampleFrameworkDb.Conventions.JsonContractResolver = new DPContractResolver(); sampleFrameworkDb.Conventions.ShouldCacheRequest = url => false; sampleFrameworkDb.Conventions.CustomizeJsonSerializer = serializer => { serializer.ContractResolver = new DPContractResolver(); serializer.Converters.Add(new ModelCreationConverter()); }; sampleFrameworkDb.Initialize(); sampleFrameworkDb.DatabaseCommands.DisableAllCaching(); ObjectFactory.Initialize(x => { x.AddRegistry(new RavenDbRegistry(sampleFrameworkDb)); x.AddRegistry(new RepositoryRegistry()); }); }
public void can_persist_and_query_documents() { using (var store = new EmbeddableDocumentStore { RunInMemory = true, DataDirectory = "RavenData" } ) { store.Initialize(); using (var session = store.OpenSession()) { var user = new User { Email = "*****@*****.**", FirstName = "Micky", LastName = "Bubbles", }; session.Store(user); session.SaveChanges(); Assert.AreEqual(true, session.Query<User>().Where(x => x.Email == "*****@*****.**").Any()); } } }
public RavenDB_2767() { store = NewDocumentStore(); var workContext = store.SystemDatabase.WorkContext; prefetchingBehavior = new PrefetchingBehavior(PrefetchingUser.Indexer, workContext, new IndexBatchSizeAutoTuner(workContext)); prefetchingBehavior.ShouldHandleUnusedDocumentsAddedAfterCommit = true; }
public void WhenAnEventIsWrittenToTheSinkItIsRetrievableFromTheDocumentStore() { using (var documentStore = new EmbeddableDocumentStore {RunInMemory = true}.Initialize()) { var timestamp = new DateTimeOffset(2013, 05, 28, 22, 10, 20, 666, TimeSpan.FromHours(10)); var exception = new ArgumentException("Mládek"); const LogEventLevel level = LogEventLevel.Information; const string messageTemplate = "{Song}++"; var properties = new List<LogEventProperty> { new LogEventProperty("Song", new ScalarValue("New Macabre")) }; using (var ravenSink = new RavenDBSink(documentStore, 2, TinyWait, null)) { var template = new MessageTemplateParser().Parse(messageTemplate); var logEvent = new Events.LogEvent(timestamp, level, exception, template, properties); ravenSink.Emit(logEvent); } using (var session = documentStore.OpenSession()) { var events = session.Query<LogEvent>().Customize(x => x.WaitForNonStaleResults()).ToList(); Assert.AreEqual(1, events.Count); var single = events.Single(); Assert.AreEqual(messageTemplate, single.MessageTemplate); Assert.AreEqual("\"New Macabre\"++", single.RenderedMessage); Assert.AreEqual(timestamp, single.Timestamp); Assert.AreEqual(level, single.Level); Assert.AreEqual(1, single.Properties.Count); Assert.AreEqual("New Macabre", single.Properties["Song"]); Assert.AreEqual(exception.Message, single.Exception.Message); } } }
public ProjectionTests() { documentStore = NewDocumentStore(configureStore: store => store.RegisterListener(new NoStaleQueriesAllowed())); session = documentStore.OpenSession(); Setup(); }
public void SuccessTest1() { using (IDocumentStore documentStore = new EmbeddableDocumentStore { RunInMemory = true }.Initialize()) { dynamic expando = new ExpandoObject(); using (IDocumentSession session = documentStore.OpenSession()) { session.Store(expando); RavenJObject metadata = session.Advanced.GetMetadataFor((ExpandoObject)expando); metadata[PropertyName] = RavenJToken.FromObject(true); session.SaveChanges(); } using (IDocumentSession session = documentStore.OpenSession()) { var loaded = session.Load<dynamic>((string)expando.Id); RavenJObject metadata = session.Advanced.GetMetadataFor((DynamicJsonObject)loaded); RavenJToken token = metadata[PropertyName]; Assert.NotNull(token); Assert.True(token.Value<bool>()); } } }
public void Should_give_documents_where_ExpirationDate_is_null_or_expirationdate_greater_than_today() { using (var documentStore = new EmbeddableDocumentStore { RunInMemory = true, Conventions = { DefaultQueryingConsistency = ConsistencyOptions.QueryYourWrites } }) { documentStore.Initialize(); using (var session = documentStore.OpenSession()) { session.Store(new Foo()); session.Store(new Foo()); session.SaveChanges(); } using (var session = documentStore.OpenSession()) { var bar = session.Query<Foo>() .Where(foo => foo.ExpirationTime == null || foo.ExpirationTime > DateTime.Now) .ToList(); Assert.That(bar.Count, Is.EqualTo(2)); } } }
static void Main(string[] args) { var cfg = new HttpSelfHostConfiguration("http://localhost:1337"); cfg.MaxReceivedMessageSize = 16L * 1024 * 1024 * 1024; cfg.TransferMode = TransferMode.StreamedRequest; cfg.ReceiveTimeout = TimeSpan.FromMinutes(20); cfg.Routes.MapHttpRoute( "API Default", "api/{controller}/{id}", new { id = RouteParameter.Optional }); cfg.Routes.MapHttpRoute( "Default", "{*res}", new { controller = "StaticFile", res = RouteParameter.Optional }); var db = new EmbeddableDocumentStore { DataDirectory = new FileInfo("db/").DirectoryName }; db.Initialize(); cfg.Filters.Add(new RavenDbApiAttribute(db)); using (HttpSelfHostServer server = new HttpSelfHostServer(cfg)) { Console.WriteLine("Initializing server."); server.OpenAsync().Wait(); Console.WriteLine("Server ready at: " + cfg.BaseAddress); Console.WriteLine("Press Enter to quit."); Console.ReadLine(); } }
public void ReturnsBooksByPriceLimit() { using (var docStore = new EmbeddableDocumentStore { RunInMemory = true } .Initialize() ) { using (var session = docStore.OpenSession()) { // Store test data session.Store(new Book { Title = "Test book", YearPublished = 2013, Price = 12.99 }); session.SaveChanges(); } var controller = new BooksController { RavenSession = docStore.OpenSession() }; var viewResult = (ViewResult)controller.ListByPriceLimit(15); var result = viewResult.ViewData.Model as List<Book>; Assert.IsNotNull(result); Assert.AreEqual(1, result.Count); viewResult = (ViewResult)controller.ListByPriceLimit(10); result = viewResult.ViewData.Model as List<Book>; Assert.IsNotNull(result); Assert.AreEqual(0, result.Count); controller.RavenSession.Dispose(); } }
protected void Application_Start() { GlobalConfiguration.Configure(WebApiConfig.Register); AreaRegistration.RegisterAllAreas(); FilterConfig.RegisterGlobalFilters(GlobalFilters.Filters); RouteConfig.RegisterRoutes(RouteTable.Routes); BundleConfig.RegisterBundles(BundleTable.Bundles); DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RequiredIfAttribute), typeof(RequiredIfValidator)); DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(AssertThatAttribute), typeof(AssertThatValidator)); // override standard error messages ClientDataTypeModelValidatorProvider.ResourceClassKey = "DefaultResources"; DefaultModelBinder.ResourceClassKey = "DefaultResources"; DataAnnotationsModelValidatorProvider.RegisterAdapter(typeof(RequiredAttribute), typeof(MyRequiredAttributeAdapter)); // setting locale var culture = new CultureInfo("nb-NO"); Thread.CurrentThread.CurrentCulture = culture; Thread.CurrentThread.CurrentUICulture = culture; // init log4net log4net.Config.XmlConfigurator.Configure(); MvcHandler.DisableMvcResponseHeader = true; Store = new EmbeddableDocumentStore { ConnectionStringName = "RavenDB" }; Store.Initialize(); }
public void ShouldOnlyBeInDataDir() { IOExtensions.DeleteDirectory("App_Data"); IOExtensions.DeleteDirectory("Data"); Assert.False(Directory.Exists("App_Data")); Assert.False(Directory.Exists("Data")); using (var store = new EmbeddableDocumentStore {DataDirectory = "App_Data"}.Initialize()) { using (var session = store.OpenSession()) { string someEmail = "*****@*****.**"; session.Query<User>().Where(u => u.Email == someEmail).FirstOrDefault(); session.Store(new User {Email = "*****@*****.**"}); session.SaveChanges(); session.Query<User>() .Customize(x => x.WaitForNonStaleResultsAsOfNow()) .Where(u => u.Email == someEmail) .Single(); } } Assert.True(Directory.Exists("App_Data")); Assert.False(Directory.Exists("Data")); IOExtensions.DeleteDirectory("App_Data"); IOExtensions.DeleteDirectory("Data"); }
public Class1() { Person myObject = new Person() { Date = DateTime.Now, Name = "Jack" }; var documentStore = new EmbeddableDocumentStore() { DataDirectory = "Data" }; documentStore.Initialize(); Console.WriteLine("inited"); var session = documentStore.OpenSession(); Console.WriteLine("session open"); session.Store(myObject); session.SaveChanges(); Console.WriteLine("changes saved"); Thread.Sleep(1000); foreach (Person queryResponse in session.Query<Person>().Where(o => o.Name == "Jack")) { Console.WriteLine(queryResponse.Name + "."); } Console.WriteLine("done"); Console.ReadLine(); }
public ScriptHelper() { var p1 = Path.Combine("Data", "System.db"); SystemStore = new EmbeddableDocumentStore { DataDirectory = p1 }; SystemStore.Initialize(); System = SystemStore.OpenSession(); SystemStore.Conventions.RegisterIdConvention<DbSetting>((db, cmds, setting) => "Settings/" + setting.Name); SystemStore.Conventions.RegisterIdConvention<DbScript>((db, cmds, script) => "Scripts/" + script.Name); try { SystemStore.DatabaseCommands.PutIndex("Settings/ByName", new IndexDefinitionBuilder<DbSetting> { Map = settings => from setting in settings select new { setting.Name } }); SystemStore.DatabaseCommands.PutIndex("Scripts/ByName", new IndexDefinitionBuilder<DbScript> { Map = scripts => from script in scripts select new { script.Name } }); } catch (Exception) { } IndexCreation.CreateIndexes(typeof(DbScript).Assembly,SystemStore); IndexCreation.CreateIndexes(typeof(DbSetting).Assembly, SystemStore); }
public void AddTest() { var cacheKey = new CacheKey("/api/Cars", new[] { "1234", "abcdef" }); var documentStore = new EmbeddableDocumentStore() { RunInMemory = true }.Initialize(); new RavenDocumentsByEntityName().Execute(documentStore); var store = new RavenDbEntityTagStore(documentStore); var value = new TimedEntityTagHeaderValue("\"abcdef1234\"") { LastModified = DateTime.Now }; // first remove them store.RemoveAllByRoutePattern(cacheKey.RoutePattern); // add store.AddOrUpdate(cacheKey, value); // get TimedEntityTagHeaderValue dbValue; store.TryGetValue(cacheKey, out dbValue); Assert.AreEqual(value.Tag, dbValue.Tag); Assert.AreEqual(value.LastModified.ToString(), dbValue.LastModified.ToString()); }
public when_querying_cases_by_name_using_danish_collation() { var culture = new CultureInfo("da"); Thread.CurrentThread.CurrentCulture = culture; Thread.CurrentThread.CurrentUICulture = culture; store = new EmbeddableDocumentStore { RunInMemory = true }; store.Initialize(); using (var session = store.OpenSession()) { session.Store(new Case { Name = "bcda" }); session.Store(new Case { Name = "dacb" }); session.Store(new Case { Name = "daab" }); session.Store(new Case { Name = "dacb" }); session.Store(new Case { Name = "aacb" }); session.Store(new Case { Name = "aaac" }); session.Store(new Case { Name = "bcbb" }); session.Store(new Case { Name = "acba" }); session.Store(new Case { Name = "aaaa" }); session.Store(new Case { Name = "dada" }); session.SaveChanges(); } }
public IDocumentStore GetRavenDBStore() { var hasRavenConnectionString = ConfigurationManager.ConnectionStrings["RavenDB"] != null; IDocumentStore docStore; if (hasRavenConnectionString) { docStore = new DocumentStore { ConnectionStringName = "RavenDB", DefaultDatabase = "BusRouteLondonDB" }; } else { //NonAdminHttp.EnsureCanListenToWhenInNonAdminContext(8080); docStore = new EmbeddableDocumentStore { //RunInMemory = true, DataDirectory = "~/App_Data/Raven", //UseEmbeddedHttpServer = true }; } docStore.Initialize(); docStore.Conventions.RegisterIdConvention<BusRoute>( (dbName, command, route) => string.Format("busroutes/{0}-{1}-{2}", route.Route, route.Run, route.Sequence)); return docStore; }
protected AuthenticationTest() { database::Raven.Database.Extensions.IOExtensions.DeleteDirectory("Data"); embeddedStore = new EmbeddableDocumentStore() { Configuration = { AnonymousUserAccessMode = database::Raven.Database.Server.AnonymousUserAccessMode.Get, Catalog = {Catalogs = {new AssemblyCatalog(typeof (AuthenticationUser).Assembly)}}, DataDirectory = "Data", RunInUnreliableYetFastModeThatIsNotSuitableForProduction = true, AuthenticationMode = "oauth", Port = 8079, OAuthTokenCertificate = database::Raven.Database.Config.CertGenerator.GenerateNewCertificate("RavenDB.Test") }, UseEmbeddedHttpServer = true, }; embeddedStore.Configuration.Initialize(); embeddedStore.Initialize(); store = new DocumentStore { Url = embeddedStore.Configuration.ServerUrl, }; store.Initialize(); store.JsonRequestFactory. EnableBasicAuthenticationOverUnsecureHttpEvenThoughPasswordsWouldBeSentOverTheWireInClearTextToBeStolenByHackers = true; foreach (DictionaryEntry de in HttpRuntime.Cache) { HttpRuntime.Cache.Remove((string)de.Key); } }
public void WorkWithTransactionAndNoAllowNonAutoritiveInformation() { using (var store = new EmbeddableDocumentStore { RunInMemory = true }.Initialize()) { using (new TransactionScope()) { using (IDocumentSession session = store.OpenSession()) { var user = new User {Id = "users/[email protected]"}; session.Store(user); session.SaveChanges(); } using(new TransactionScope(TransactionScopeOption.Suppress)) using (IDocumentSession session = store.OpenSession()) { var user = session.Load<User>("users/[email protected]"); Assert.Null(user); } } } }
public PostSchedulingStrategyTests() { Now = DateTimeOffset.Now; DocumentStore = new EmbeddableDocumentStore { RunInMemory = true }.Initialize(); Session = DocumentStore.OpenSession(); }
public void Test_paralel_operations_with_multiple_EmbeddableDocumentStores() { Action storeAndRead = () => { using (var store = new EmbeddableDocumentStore { RunInMemory = true }) { store.Initialize(); using (var session = store.OpenSession()) { session.Store(new Document { Value = "foo" }, "documents/1"); session.SaveChanges(); } using (var session = store.OpenSession()) { var doc = session.Load<Document>("documents/1"); Assert.Equal("foo", doc.Value); } } }; storeAndRead(); var tasks = Enumerable.Range(1, 10).Select(_ => Task.Run(storeAndRead)).ToArray(); Task.WaitAll(tasks); }
/// <summary> /// Creates the kernel that will manage your application. /// </summary> /// <returns>The created kernel.</returns> private static IKernel CreateKernel() { var documentStore = new EmbeddableDocumentStore { UseEmbeddedHttpServer = true, DataDirectory = "App_Data", Configuration = { Port = 12345, }, Conventions = { CustomizeJsonSerializer = MvcApplication.SetupSerializer } }; documentStore.Initialize(); var manager = new SubscriptionManager(documentStore); var kernel = new StandardKernel(); kernel.Bind<Func<IKernel>>().ToMethod(ctx => () => new Bootstrapper().Kernel); kernel.Bind<IHttpModule>().To<HttpApplicationInitializationHttpModule>(); kernel.Bind<IDocumentStore>() .ToMethod(context => documentStore) .InSingletonScope(); RegisterServices(kernel); kernel.Bind<SubscriptionManager>().ToMethod(context => manager).InSingletonScope(); return kernel; }
public RavenServer(Action<EmbeddableDocumentStore> initialization = null) { int port = 32076; DocumentStore = new EmbeddableDocumentStore { DataDirectory = "Data", UseEmbeddedHttpServer = true, DefaultDatabase = "NServiceBus", Configuration = { Port = port, PluginsDirectory = Environment.CurrentDirectory, HostName = "localhost" } }; if (initialization != null) { initialization(DocumentStore); } DocumentStore.Initialize(); //since we are hosting a fake raven server in process we need to remove it from the logging pipeline Trace.Listeners.Clear(); Trace.Listeners.Add(new DefaultTraceListener()); ManagementUrl = string.Format("http://localhost:{0}/", port); Console.WriteLine("Raven server started on {0}" + ManagementUrl); }
public EmbeddableDocumentStore NewDocumentStore(string storageType, bool inMemory, int? allocatedMemory) { path = Path.GetDirectoryName(Assembly.GetAssembly(typeof(DocumentStoreServerTests)).CodeBase); path = Path.Combine(path, "TestDb").Substring(6); var documentStore = new EmbeddableDocumentStore() { Configuration = { DataDirectory = path, RunInUnreliableYetFastModeThatIsNotSuitableForProduction = true, DefaultStorageTypeName = storageType, RunInMemory = inMemory, } }; ModifyStore(documentStore); ModifyConfiguration(documentStore.Configuration); if (documentStore.Configuration.RunInMemory == false) IOExtensions.DeleteDirectory(path); documentStore.Initialize(); CreateDefaultIndexes(documentStore); if (allocatedMemory != null && inMemory) { var transactionalStorage = ((TransactionalStorage)documentStore.DocumentDatabase.TransactionalStorage); transactionalStorage.EnsureCapacity(allocatedMemory.Value); } return documentStore; }
public void ShouldWork() { using (var _documentStore = new EmbeddableDocumentStore { RunInMemory = true, Conventions = { DefaultQueryingConsistency = ConsistencyOptions.QueryYourWrites } }) { _documentStore.Initialize(); using (var session = _documentStore.OpenSession()) { session.Store(new Foo()); session.Store(new Foo()); session.SaveChanges(); } using (var session = _documentStore.OpenSession()) { var bar = session.Query<Foo>().Where(foo => foo.ExpirationTime == null || foo.ExpirationTime > DateTime.Now).ToList(); Assert.Equal(2, bar.Count); } } }
public void SuccessTest2() { using (IDocumentStore documentStore = new EmbeddableDocumentStore { RunInMemory = true }.Initialize()) { dynamic expando = new ExpandoObject(); using (IDocumentSession session = documentStore.OpenSession()) { session.Store(expando); RavenJObject metadata = session.Advanced.GetMetadataFor((ExpandoObject)expando); metadata[PropertyName] = RavenJToken.FromObject(true); session.SaveChanges(); } using (IDocumentSession session = documentStore.OpenSession()) { dynamic loaded = session.Advanced.LuceneQuery<dynamic>() .WhereEquals("@metadata.Raven-Entity-Name", documentStore.Conventions.GetTypeTagName(typeof(ExpandoObject))) .FirstOrDefault(); Assert.NotNull(loaded); } } }
public CommandStorageTests() { _store = new EmbeddableDocumentStore(); // _store.DataDirectory = Environment.CurrentDirectory + "Db"; _store.RunInMemory = true; _store.Initialize(); }
protected IDocumentStore NewInMemoryStore() { IDocumentStore documentStore = new Raven.Client.Embedded.EmbeddableDocumentStore() { RunInMemory = true, }; documentStore.Initialize(); return(documentStore); }
public EmbeddedAsyncServerClient(EmbeddableDocumentStore db, IDatabaseCommands databaseCommands) { this.db = db; this.databaseCommands = databaseCommands; OperationsHeaders = new DictionaryWrapper(databaseCommands.OperationsHeaders); }