public void GivenSomeUsers_QueryWithAnIndex_ReturnsUsersWithNamesReversed() { using (EmbeddableDocumentStore store = NewDocumentStore()) { store.DatabaseCommands.PutIndex("StringReverseIndex", new IndexDefinition { Map = "from doc in docs select new { doc.Name, ReverseName = doc.Name.Reverse()}" }); using (IDocumentSession documentSession = store.OpenSession()) { documentSession.Store(new User { Name = "Ayende" }); documentSession.Store(new User { Name = "Itamar" }); documentSession.Store(new User { Name = "Pure Krome" }); documentSession.Store(new User { Name = "John Skeet" }); documentSession.Store(new User { Name = "StackOverflow" }); documentSession.Store(new User { Name = "Wow" }); documentSession.SaveChanges(); } using (IDocumentSession documentSession = store.OpenSession()) { var users = documentSession .Query <User>("StringReverseIndex") .Customize(x => x.WaitForNonStaleResults()) .ToList(); Assert.Empty(store.SystemDatabase.Statistics.Errors); Assert.NotNull(users); Assert.True(users.Count > 0); } } }
public void FourOrClauses_fails() { using (EmbeddableDocumentStore store = NewDocumentStore()) { store.Initialize(); var itemList = new List <Item> { new Item("A") }; using (IDocumentSession s = store.OpenSession()) { s.Store(new MyDoc { Foo = "monkey", ItemListOne = itemList, ItemListTwo = itemList, ItemListThree = itemList, ItemListFour = itemList }); s.Store(new MyDoc { Foo = "monkey", ItemListOne = itemList, ItemListTwo = itemList, ItemListThree = itemList, ItemListFour = itemList }); s.SaveChanges(); } using (IDocumentSession s = store.OpenSession()) { MyDoc[] res = s.Query <MyDoc>() .Where(x => x.Foo == "monkey" && ( x.ItemListOne.Any(i => i.MyProp == "A") || x.ItemListTwo.Any(i => i.MyProp == "A") || x.ItemListThree.Any(i => i.MyProp == "A") || x.ItemListFour.Any(i => i.MyProp == "A"))) //Additional Or clause .OrderByDescending(x => x.CreatedDate) .ToArray(); Assert.True(res.Count() == 2); } } }
public void can_index_on_a_reference2() { using (var store = new EmbeddableDocumentStore { RunInMemory = true }) { store.Initialize(); using (var session = store.OpenSession()) { var category = new Category() { Name = "Parent" }; category.Add(new Category() { Name = "Child" }); session.Store(category); session.SaveChanges(); } using (var session = store.OpenSession()) { var results0 = session.Query <Category>() .Customize(x => x.WaitForNonStaleResults(TimeSpan.FromHours(1))) .ToList(); Assert.Equal(1, results0.Count); // WORKS var results1 = session.Query <Category>() .Customize(x => x.WaitForNonStaleResults()) .Where(x => x.Children.Any(y => y.Name == "Child")). ToList(); Assert.Equal(1, results1.Count); // FAILS var results2 = session.Query <Category>() .Customize(x => x.WaitForNonStaleResults()) .Where(x => x.Children.Any(y => y.Parent.Name == "Parent")) .ToList(); Assert.Equal(1, results2.Count); } } }
public AccountRepositoryTests() { _documentStore = new EmbeddableDocumentStore { Conventions = { IdentityPartsSeparator = "-" } }; _documentStore.Initialize(); _session = _documentStore.OpenSession(); }
protected void SetupData(Action <IDocumentSession> action) { using (var session = documentStore.OpenSession()) { action(session); session.SaveChanges(); } }
public void write_then_read_from_stack_over_flow_types() { using (EmbeddableDocumentStore documentStore = NewDocumentStore()) { new QuestionWithVoteTotalIndex().Execute(documentStore); const string questionId = @"question/259"; using (IDocumentSession session = documentStore.OpenSession()) { var user = new User { Id = @"user/222", DisplayName = "John Doe" }; session.Store(user); var question = new Question { Id = questionId, Title = "How to do this in RavenDb?", Content = "I'm trying to find how to model documents for better DDD support.", UserId = @"user/222" }; session.Store(question); var vote1 = new QuestionVote { QuestionId = questionId, Delta = 2 }; session.Store(vote1); var vote2 = new QuestionVote { QuestionId = questionId, Delta = 3 }; session.Store(vote2); session.SaveChanges(); } using (IDocumentSession session = documentStore.OpenSession()) { QuestionView questionInfo = session.Query <QuestionView, QuestionWithVoteTotalIndex>() .Customize(x => x.WaitForNonStaleResultsAsOfNow()) .Where(x => x.QuestionId == questionId) .SingleOrDefault(); Assert.NotNull(questionInfo); Assert.False(string.IsNullOrEmpty(questionInfo.User.DisplayName), "User.DisplayName was not loaded"); } } }
public IDocumentSession GetSession() { lock (isStoreSet) { if (!(bool)isStoreSet) { RavenConfiguration ravenConfiguration = null; bool webUIEnabled = false; int webUIPort = 0; var config = ConfigurationManager.OpenExeConfiguration(ConfigurationUserLevel.None); var serviceConfigurationSection = config.GetSection("ServiceConfigurationSection") as ServiceConfigurationSection; if (serviceConfigurationSection != null) { ravenConfiguration = serviceConfigurationSection.ravendb; if (ravenConfiguration != null) { webUIEnabled = ravenConfiguration.WebUIEnabled; webUIPort = ravenConfiguration.WebUIPort; if (webUIEnabled) { if (webUIPort < 0 || webUIPort > 65535) { webUIEnabled = false; } else { webUIEnabled = CheckPortIsAvailable(webUIPort); } } } } documentStore = new EmbeddableDocumentStore(); documentStore.Configuration.DataDirectory = "Data\\RavenDB"; documentStore.Configuration.DefaultStorageTypeName = typeof(Raven.Storage.Esent.TransactionalStorage).AssemblyQualifiedName; documentStore.Conventions.FindIdentityProperty = x => x.Name == "Oid"; documentStore.Conventions.MaxNumberOfRequestsPerSession = 1000; documentStore.Initialize(); IndexCreation.CreateIndexes(GetType().Assembly, documentStore); if (webUIEnabled) { documentStore.Configuration.Port = webUIPort; var httpServer = new HttpServer(documentStore.Configuration, documentStore.DocumentDatabase); httpServer.Init(); httpServer.StartListening(); } isStoreSet = true; } } return(documentStore.OpenSession()); }
public RepositoryContext() { _documentStore = new EmbeddableDocumentStore() { ConnectionStringName = "ContentRepository" }; _documentStore.Initialize(); _session = _documentStore.OpenSession(); }
public WhereStringEqualsInCollection() { store = NewDocumentStore(); using (var session = store.OpenSession()) { session.Store(new MyEntity { StringData = "Entity with collection", StringCollection = new List<string> { "CollectionItem1", "CollectionItem2" } }); session.SaveChanges(); } }
public PostSchedulingStrategyTests() { Now = DateTimeOffset.Now; DocumentStore = new EmbeddableDocumentStore { RunInMemory = true }.Initialize(); Session = DocumentStore.OpenSession(); }
public void versioning_should_work() { var store = new EmbeddableDocumentStore { RunInMemory = true }; store.Configuration.Settings.Add("Raven/ActiveBundles", "Versioning"); store.Initialize(); using (IDocumentSession db = store.OpenSession()) { db.Store(new VersioningConfiguration { Exclude = false, Id = "Raven/Versioning/Items", MaxRevisions = int.MaxValue }); db.SaveChanges(); } using (IDocumentSession db = store.OpenSession()) { db.Store(new Item { Value = "first revision" }); db.SaveChanges(); } using (IDocumentSession db = store.OpenSession()) { Item item = db.Query <Item>().Customize(x => x.WaitForNonStaleResults()).First(); item.Value = "second revision"; db.SaveChanges(); } using (IDocumentSession db = store.OpenSession()) { Item item = db.Query <Item>().Customize(x => x.WaitForNonStaleResults()).First(); string id = db.Advanced.GetDocumentId(item); Item[] revisions = db.Advanced.GetRevisionsFor <Item>(id, 0, 10); revisions.Should().NotBeEmpty(); } }
public void Can_Use_In_IEnumerable_Not_In_Where_Clause_on_Id() { using (var store = new EmbeddableDocumentStore() { RunInMemory = true }) { store.Initialize(); var guid1 = Guid.NewGuid(); var guid2 = Guid.NewGuid(); var customerId = Guid.NewGuid(); using (var s = store.OpenSession()) { s.Store(new OrderItem { Id = Guid.NewGuid(), CustomerId = customerId, Cost = 1.59m, Quantity = 5 }); s.Store(new OrderItem { Id = guid1, CustomerId = customerId, Cost = 7.59m, Quantity = 3 }); s.Store(new OrderItem { Id = guid2, CustomerId = customerId, Cost = 1.59m, Quantity = 4 }); s.Store(new OrderItem { Id = Guid.NewGuid(), CustomerId = customerId, Cost = 1.39m, Quantity = 3 }); s.SaveChanges(); } var list = new List <Guid> { guid1 }; //, guid2 }; using (var s = store.OpenSession()) { var items = (from item in s.Query <OrderItem>() where item.Quantity > 4 && item.CustomerId == customerId && !item.Id.In(list) select item ).ToArray(); Assert.Equal(items.Length, 1); } } }
public void ShouldDeleteDocumentTombStoneAfterNextPut() { using (EmbeddableDocumentStore store = NewDocumentStore()) { // create document string userId; using (var session = store.OpenSession()) { var user = new User { Name = "oren" }; session.Store(user); userId = user.Id; session.SaveChanges(); } //now delete it and check for tombstone using (var session = store.OpenSession()) { session.Delete(userId); session.SaveChanges(); } store.SystemDatabase.TransactionalStorage.Batch(accessor => { var tombstone = accessor.Lists.Read(Constants.RavenPeriodicExportsDocsTombstones, userId); Assert.NotNull(tombstone); }); using (var session = store.OpenSession()) { session.Store(new User { Name = "ayende" }, userId); session.SaveChanges(); } store.SystemDatabase.TransactionalStorage.Batch(accessor => { var tombstone = accessor.Lists.Read(Constants.RavenPeriodicExportsDocsTombstones, userId); Assert.Null(tombstone); }); } }
//Failing test from http://groups.google.com/group/ravendb/browse_thread/thread/7a93f37036297d48/ public void CanSuccessfullyDoSpatialQueryOfNearbyLocations() { // These items is in a radius of 4 miles (approx 6,5 km) var areaOneDocOne = new DummyGeoDoc(55.6880508001, 13.5717346673); var areaOneDocTwo = new DummyGeoDoc(55.6821978456, 13.6076183965); var areaOneDocThree = new DummyGeoDoc(55.673251569, 13.5946697607); // This item is 12 miles (approx 19 km) from the closest in areaOne var closeButOutsideAreaOne = new DummyGeoDoc(55.8634157297, 13.5497731987); // This item is about 3900 miles from areaOne var newYork = new DummyGeoDoc(40.7137578228, -74.0126901936); using (var documentStore = new EmbeddableDocumentStore { RunInMemory = true }.Initialize()) using (var session = documentStore.OpenSession()) { session.Store(areaOneDocOne); session.Store(areaOneDocTwo); session.Store(areaOneDocThree); session.Store(closeButOutsideAreaOne); session.Store(newYork); session.SaveChanges(); var indexDefinition = new IndexDefinition { Map = "from doc in docs select new { _ = SpatialIndex.Generate(doc.Latitude, doc.Longitude) }" }; documentStore.DatabaseCommands.PutIndex("FindByLatLng", indexDefinition); // Wait until the index is built session.Advanced.LuceneQuery <DummyGeoDoc>("FindByLatLng") .WaitForNonStaleResults() .ToArray(); const double lat = 55.6836422426, lng = 13.5871808352; // in the middle of AreaOne const double radius = 5.0; // Expected is that 5.0 will return 3 results var nearbyDocs = session.Advanced.LuceneQuery <DummyGeoDoc>("FindByLatLng") .WithinRadiusOf(radius, lat, lng) .WaitForNonStaleResults() .ToArray(); Assert.NotEqual(null, nearbyDocs); Assert.Equal(3, nearbyDocs.Length); //TODO //var dist = DistanceUtils.GetInstance(); //Assert.Equal(true, nearbyDocs.All(x => dist.GetDistanceMi(x.Latitude, x.Longitude, lat, lng) < radius)); session.Dispose(); } }
public void AllowNonAuthoratativeInformationAlwaysWorks() { const int callCount = 10000; using (IDocumentStore documentStore = new EmbeddableDocumentStore { RunInMemory = true }) { documentStore.Initialize(); int documentId; // create test document using (IDocumentSession session = documentStore.OpenSession()) { var testDocument = new TestDocument(); session.Store(testDocument); session.SaveChanges(); documentId = testDocument.Id; } // do many 'set property and check value' tests for (int i = 0; i < callCount; i++) { using (IDocumentSession session = documentStore.OpenSession()) using (var tx = new TransactionScope()) { session.Load <TestDocument>(documentId).Value = i; session.SaveChanges(); tx.Complete(); } using (IDocumentSession session = documentStore.OpenSession()) { session.Advanced.AllowNonAuthoritativeInformation = false; var loadedDoc = session.Load <TestDocument>(documentId); Assert.Equal(i, loadedDoc.Value); } } } }
public void AddUserToProjectSuccess() { var pm = new ProjectManager { Session = _embeddedDocStore.OpenSession() }; pm.AddUserToProject(_existingProject.Name, _newActiveUser.Username, _existingUser.Username); var session = _embeddedDocStore.OpenSession(); var updatedProject = session.Query <Project>().Where(p => p.Name == _existingProject.Name).First(); Assert.IsTrue(updatedProject.Users.Contains(_newActiveUser.Username)); }
protected static IDocumentSession WithEmptySession() { var store = new EmbeddableDocumentStore { RunInMemory = true, Configuration = { Storage = { Voron = { AllowOn32Bits = true } } } }.Initialize(); return(store.OpenSession()); }
public void Can_perform_Boolean_Queries() { using (var db = new EmbeddableDocumentStore() { RunInMemory = true }) { db.Initialize(); string indexName = "UserIndex"; using (var session = db.OpenSession()) { session.Store(new User() { Name = "Matt", Info = "Male Age 25" }); //Active = false by default session.Store(new User() { Name = "Matt", Info = "Male Age 28", Active = true }); session.Store(new User() { Name = "Matt", Info = "Male Age 35", Active = false }); session.SaveChanges(); db.DatabaseCommands.DeleteIndex(indexName); var result = db.DatabaseCommands.PutIndex <User, User>(indexName, new IndexDefinitionBuilder <User, User>() { Map = docs => from doc in docs select new { doc.Name, doc.Age, doc.Info, doc.Active }, Indexes = { { x => x.Name, FieldIndexing.Analyzed } } }, true); WaitForQueryToComplete(session, indexName); var testQuery = session.Query <User>(indexName) .Where(x => x.Name == ("Matt") && x.Active); Assert.Equal(1, testQuery.ToArray().Count()); foreach (var testResult in testQuery) { Assert.True(testResult.Active); } testQuery = session.Query <User>(indexName) .Where(x => x.Name == ("Matt") && !x.Active); Assert.Equal(2, testQuery.ToArray().Count()); foreach (var testResult in testQuery) { Assert.False(testResult.Active); } } } }
public void Spatial_Search_Should_Integrate_Distance_As_A_Boost_Factor() { using (var store = new EmbeddableDocumentStore { RunInMemory = true }.Initialize()) { store.ExecuteIndex(new SpatialIndex()); using (var session = store.OpenSession()) { session.Store(new SpatialEntity(45.70955, -73.569131) // 22.23 Kb { Id = "se/1", }); session.Store(new SpatialEntity(45.50955, -73.569131) // 0 Km { Id = "se/2", }); session.Store(new SpatialEntity(45.60955, -73.569131) // 11.11 KM { Id = "se/3", }); session.SaveChanges(); } WaitForIndexing(store); using (var session = store.OpenSession()) { var results = session.Advanced.LuceneQuery <SpatialEntity>("SpatialIndex") .WithinRadiusOf(500, 45.50955, -73.569133) .ToList(); Assert.Equal(results[0].Id, "se/2"); Assert.Equal(results[1].Id, "se/3"); Assert.Equal(results[2].Id, "se/1"); } } }
public void TestInitialize() { // Arrange _documentStore = new EmbeddableDocumentStore { ConnectionStringName = "RavenDB" }; _documentStore.Initialize(); _session = _documentStore.OpenSession(); _controller = new MoviesController(_session); }
private void AssertProjectIsCreated(string projectName, string username) { var session = _embeddedDocStore.OpenSession(); var projectCount = session.Query <Project>().Where(p => p.Name == projectName && p.Owner == username).Count(); Assert.That(projectCount, Is.EqualTo(1)); var project = session.Query <Project>().Where(p => p.Name == projectName && p.Owner == username).First(); Assert.That(project.Users.Count(), Is.EqualTo(1)); Assert.That(project.Users[0], Is.EqualTo(username)); }
public void Can_Use_In_IEnumerable_In_Where_Clause() { using (var store = new EmbeddableDocumentStore() { RunInMemory = true }) { store.Initialize(); using (var s = store.OpenSession()) { s.Store(new OrderItem { Cost = 1.59m, Quantity = 5 }); s.Store(new OrderItem { Cost = 7.59m, Quantity = 3 }); s.Store(new OrderItem { Cost = 1.59m, Quantity = 4 }); s.Store(new OrderItem { Cost = 1.39m, Quantity = 3 }); s.SaveChanges(); } var list = new List <decimal> { 3, 5 }; using (var s = store.OpenSession()) { var items = (from item in s.Query <OrderItem>() where item.Quantity.In(list) select item ).ToArray(); Assert.Equal(items.Length, 3); } } }
public void Can_Use_Enums_In_IEnumerable_In_Where_Clause() { using (var store = new EmbeddableDocumentStore() { RunInMemory = true }) { store.Initialize(); using (var s = store.OpenSession()) { s.Store(new OrderItem { Cost = 1.59m, Quantity = 5, Country = Origin.Africa }); s.Store(new OrderItem { Cost = 7.59m, Quantity = 3, Country = Origin.Africa }); s.Store(new OrderItem { Cost = 1.59m, Quantity = 4, Country = Origin.UnitedStates }); s.Store(new OrderItem { Cost = 1.39m, Quantity = 3, Country = Origin.Africa }); s.SaveChanges(); } var list = new List <Origin> { Origin.Africa }; using (var s = store.OpenSession()) { var items = (from item in s.Query <OrderItem>() where item.Country.In(list) select item ).ToArray(); Assert.Equal(items.Length, 3); } } }
public void Can_Use_Static_Properties_In_Where_Clauses() { using (var db = new EmbeddableDocumentStore() { RunInMemory = true }) { db.Initialize(); db.DatabaseCommands.PutIndex("DateTime", new IndexDefinition { Map = @"from info in docs.DateTimeInfos select new { info.TimeOfDay }" , }); using (var s = db.OpenSession()) { s.Store(new DateTimeInfo { TimeOfDay = SystemTime.Now.AddDays(1) }); s.Store(new DateTimeInfo { TimeOfDay = SystemTime.Now.AddDays(-1) }); s.Store(new DateTimeInfo { TimeOfDay = SystemTime.Now.AddDays(1) }); s.SaveChanges(); } using (var s = db.OpenSession()) { //Just issue a blank query to make sure there are no stale results s.Query <DateTimeInfo>("DateTime") .Customize(x => x.WaitForNonStaleResults()).FirstOrDefault(); var count = s.Query <DateTimeInfo>("DateTime").Where(x => x.TimeOfDay > SystemTime.Now).Count(); Assert.Equal(2, count); } } }
private static void DoTest(DateTime dt, DateTimeKind inKind, DateTimeKind outKind) { Assert.Equal(inKind, dt.Kind); using (var documentStore = new EmbeddableDocumentStore { RunInMemory = true }) { documentStore.Initialize(); new FoosAndBars_ByDateTime().Execute(documentStore); using (var session = documentStore.OpenSession()) { session.Store(new Foo { Id = "foos/1", DateTime1 = dt }); session.Store(new Bar { Id = "bars/1", DateTime2 = dt }); session.SaveChanges(); } using (var session = documentStore.OpenSession()) { var results = session.Query <FoosAndBars_ByDateTime.Result, FoosAndBars_ByDateTime>() .Customize(x => x.WaitForNonStaleResults()) .Where(x => x.DateTime == dt) .As <object>() .ToList(); var foo = results.OfType <Foo>().First(); var bar = results.OfType <Bar>().First(); Assert.Equal(dt, foo.DateTime1); Assert.Equal(outKind, foo.DateTime1.Kind); Assert.Equal(dt, bar.DateTime2); Assert.Equal(outKind, bar.DateTime2.Kind); } } }
public void Test() { using (var session = _documentStore.OpenSession()) { TestEntity entity = new TestEntity { LastSavedDate = DateTime.Now }; session.Store(entity); session.SaveChanges(); entity = session.Include("RelatedEntityId").Load <TestEntity>(entity.Id); } }
public void Can_perform_Skip_Take_Query() { using (var db = new EmbeddableDocumentStore() { RunInMemory = true }) { db.Initialize(); string indexName = "UserIndex"; using (var session = db.OpenSession()) { AddData(session); db.DatabaseCommands.DeleteIndex(indexName); db.DatabaseCommands.PutIndex <User, User>(indexName, new IndexDefinitionBuilder <User, User>() { Map = docs => from doc in docs select new { doc.Name, doc.Age }, SortOptions = { { x => x.Name, SortOptions.StringVal } } }, true); WaitForQueryToComplete(session, indexName); var allResults = session.Query <User>(indexName).OrderBy(x => x.Name) .Where(x => x.Age > 0); Assert.Equal(4, allResults.ToArray().Count()); var takeResults = session.Query <User>(indexName).OrderBy(x => x.Name) .Where(x => x.Age > 0) .Take(3); //There are 4 items of data in the db, but using Take(1) means we should only see 4 Assert.Equal(3, takeResults.ToArray().Count()); var skipResults = session.Query <User>(indexName).OrderBy(x => x.Name) .Where(x => x.Age > 0) .Skip(1); //Using Skip(1) means we should only see the last 3 Assert.Equal(3, skipResults.ToArray().Count()); Assert.DoesNotContain(firstUser, skipResults.ToArray()); var skipTakeResults = session.Query <User>(indexName).OrderBy(x => x.Name) .Where(x => x.Age > 0) .Skip(1) .Take(2); //Using Skip(1), Take(2) means we shouldn't see the 1st or 4th (last) users Assert.Equal(2, skipTakeResults.ToArray().Count()); Assert.DoesNotContain <User>(firstUser, skipTakeResults.ToArray()); Assert.DoesNotContain <User>(lastUser, skipTakeResults.ToArray()); } } }
public void DoSomeActions() { using (var documentStore = new EmbeddableDocumentStore { RunInMemory = true }.Initialize()) { using (var session = documentStore.OpenSession()) { // Run complex test scenarious } } }
public void Can_query_active_campaigns() { using (var session = Store.OpenSession()) { var results = session.Query <VacancyCampaignsIndex.ReduceResult, VacancyCampaignsIndex>() .Customize(x => x.WaitForNonStaleResults()) .Where(x => x.Active) .AsProjection <VacancyCampaignsIndex.ReduceResult>() .ToList(); Assert.Equal(2, results.Count()); } }
private static void PutSampleData(EmbeddableDocumentStore documentStore) { using (var session = documentStore.OpenSession()) { session.Store(new Foo { Id = "foos/1", Bars = new Dictionary <string, Bar> { { "A", new Bar { Name = "A", Value = "1" } }, { "B", new Bar { Name = "B", Value = "2" } }, { "C", new Bar { Name = "C", Value = "3" } }, } }); session.Store(new Foo { Id = "foos/2", Bars = new Dictionary <string, Bar> { { "D", new Bar { Name = "D", Value = "4" } }, { "E", new Bar { Name = "E", Value = "5" } }, { "F", new Bar { Name = "F", Value = "6" } }, } }); session.Store(new Foo { Id = "foos/3", Bars = new Dictionary <string, Bar>() }); session.Store(new Foo { Id = "foos/4", Bars = new Dictionary <string, Bar>() }); session.SaveChanges(); } }