public AsyncDaemonFixture() { _store = TestingDocumentStore.For(_ => { _.DatabaseSchemaName = "expected"; _.Events.DatabaseSchemaName = "expected"; _.Events.InlineProjections.AggregateStreamsWith <ActiveProject>(); _.Events.InlineProjections.TransformEvents(new CommitViewTransform()); }); var folder = ".".ToFullPath().ParentDirectory().ParentDirectory() .AppendPath("CodeTracker"); var files = new FileSystem().FindFiles(folder, FileSet.Shallow("*.json")); AllProjects = new Dictionary <Guid, GithubProject>(); foreach (var file in files) { var project = GithubProject.LoadFrom(file); AllProjects.Add(project.Id, project); Console.WriteLine($"Loaded {project.OrganizationName}{project.ProjectName} from JSON"); } PublishAllProjectEvents(_store); }
public void will_build_the_new_table_if_the_configured_table_does_not_match_the_existing_table_on_other_schema() { DocumentTable table1; DocumentTable table2; using (var store = TestingDocumentStore.For(_ => _.DatabaseSchemaName = "other")) { store.Tenancy.Default.EnsureStorageExists(typeof(User)); store.Tenancy.Default.DbObjects.DocumentTables().ShouldContain("other.mt_doc_user"); table1 = store.TableSchema(typeof(User)); table1.ShouldNotContain(x => x.Name == "user_name"); } using (var store = DocumentStore.For(_ => { _.Connection(ConnectionSource.ConnectionString); _.DatabaseSchemaName = "other"; })) { store.Storage.MappingFor(typeof(User)).As <DocumentMapping>().DuplicateField("UserName"); store.Tenancy.Default.EnsureStorageExists(typeof(User)); store.Tenancy.Default.DbObjects.DocumentTables().ShouldContain("other.mt_doc_user"); table2 = store.TableSchema(typeof(User)); } table2.ShouldNotBe(table1); table2.Column("user_name").ShouldNotBeNull(); }
public void no_changes_in_upsert_function_95_style() { var store1 = TestingDocumentStore.For(_ => { _.DatabaseSchemaName = Marten.StoreOptions.DefaultDatabaseSchemaName; _.Schema.For <User>().Duplicate(x => x.UserName).Duplicate(x => x.Internal); }); store1.Advanced.Clean.CompletelyRemoveAll(); store1.Schema.EnsureStorageExists(typeof(User)); // Don't use TestingDocumentStore because it cleans everything upfront. var store2 = DocumentStore.For(_ => { _.Connection(ConnectionSource.ConnectionString); _.DatabaseSchemaName = Marten.StoreOptions.DefaultDatabaseSchemaName; _.Schema.For <User>().Duplicate(x => x.UserName).Duplicate(x => x.Internal); }); var mapping = store2.Schema.MappingFor(typeof(User)).As <DocumentMapping>(); var diff = mapping.SchemaObjects.As <DocumentSchemaObjects>().CreateSchemaDiff(store2.Schema); diff.AllMissing.ShouldBeFalse(); diff.FunctionDiff.HasChanged.ShouldBeFalse(); diff.HasDifferences().ShouldBeFalse(); }
public void can_fetch_indexes_for_a_table_in_public() { var store1 = TestingDocumentStore.For(_ => { _.DatabaseSchemaName = "other"; _.Schema.For <User>().Duplicate(x => x.UserName).Duplicate(x => x.Internal); }).As <DocumentStore>(); store1.Tenancy.Default.EnsureStorageExists(typeof(User)); var store2 = TestingDocumentStore.For(_ => { _.DatabaseSchemaName = Marten.StoreOptions.DefaultDatabaseSchemaName; _.Schema.For <User>().Duplicate(x => x.UserName).Duplicate(x => x.FirstName); }).As <DocumentStore>(); store2.Tenancy.Default.EnsureStorageExists(typeof(User)); var indices = store2.Tenancy.Default.DbObjects.AllIndexes(); indices.Any(x => Equals(x.Table, store1.Storage.MappingFor(typeof(User)).ToQueryableDocument().Table)) .ShouldBeFalse(); indices.Any(x => Equals(x.Table, store2.Storage.MappingFor(typeof(User)).ToQueryableDocument().Table)) .ShouldBeTrue(); }
public void can_generate_the_patch_with_camel_casing() { using (var store1 = TestingDocumentStore.For(_ => { _.UseDefaultSerialization(EnumStorage.AsString, Casing.CamelCase); })) { store1.BulkInsert(new User[] { new User { UserName = "******" }, new User { UserName = "******" } }); } using (var store2 = DocumentStore.For(_ => { _.Connection(ConnectionSource.ConnectionString); _.Schema.For <User>().SoftDeleted(); _.UseDefaultSerialization(EnumStorage.AsString, Casing.CamelCase); })) { // Verifying that we didn't lose any data using (var session = store2.QuerySession()) { session.Query <User>().OrderBy(x => x.UserName).Select(x => x.UserName) .ToList().ShouldHaveTheSameElementsAs("bar", "foo"); } var table = store2.Tenancy.Default.DbObjects.ExistingTableFor(typeof(User)); table.HasColumn(DocumentMapping.DeletedColumn).ShouldBeTrue(); table.HasColumn(DocumentMapping.DeletedAtColumn).ShouldBeTrue(); } }
public void can_fetch_schema_objects_for_a_document_type_in_the_default_schema() { var store1 = TestingDocumentStore.For(_ => { _.DatabaseSchemaName = "public"; _.Schema.For <User>().Duplicate(x => x.UserName).Duplicate(x => x.Internal); }); store1.Schema.EnsureStorageExists(typeof(User)); var objects = store1.Schema.DbObjects.FindSchemaObjects(store1.Schema.MappingFor(typeof(User)).As <DocumentMapping>()); objects.Table.Columns.OrderBy(x => x.Name).Select(x => x.Name) .ShouldHaveTheSameElementsAs("data", "id", "internal", DocumentMapping.DotNetTypeColumn, DocumentMapping.LastModifiedColumn, DocumentMapping.VersionColumn, "user_name"); objects.Function.Body.ShouldContain("CREATE OR REPLACE FUNCTION public.mt_upsert_user"); objects.ActualIndices.Select(x => x.Value).OrderBy(x => x.Name).Select(x => x.Name) .ShouldHaveTheSameElementsAs("mt_doc_user_idx_internal", "mt_doc_user_idx_user_name"); }
public void detect_change_in_upsert_function_95_style() { var store1 = TestingDocumentStore.For(_ => { _.UpsertType = PostgresUpsertType.Standard; _.DatabaseSchemaName = Marten.StoreOptions.DefaultDatabaseSchemaName; //_.Schema.For<User>().Searchable(x => x.UserName).Searchable(x => x.Internal); }); store1.Schema.EnsureStorageExists(typeof(User)); // Don't use TestingDocumentStore because it cleans everything upfront. var store2 = DocumentStore.For(_ => { _.UpsertType = PostgresUpsertType.Standard; _.Connection(ConnectionSource.ConnectionString); _.DatabaseSchemaName = Marten.StoreOptions.DefaultDatabaseSchemaName; _.Schema.For <User>().Searchable(x => x.UserName).Searchable(x => x.Internal); }); var mapping = store2.Schema.MappingFor(typeof(User)).As <DocumentMapping>(); var diff = mapping.SchemaObjects.As <DocumentSchemaObjects>().CreateSchemaDiff(store2.Schema); diff.AllMissing.ShouldBeFalse(); diff.HasFunctionChanged().ShouldBeTrue(); }
public void can_override_with_MartenRegistry() { var store = TestingDocumentStore.For(_ => { _.Schema.For <Organization>().Duplicate(x => x.Time2, pgType: "timestamp"); }); store.Storage.MappingFor(typeof(Organization)).As <DocumentMapping>().DuplicatedFields.Single(x => x.MemberName == "Time2") .PgType.ShouldBe("timestamp"); }
public void can_configure_deletion_style_by_fluent_interface() { using (var store = TestingDocumentStore.For(_ => { _.Schema.For <User>().SoftDeleted(); })) { store.Schema.MappingFor(typeof(User)).As <DocumentMapping>() .DeleteStyle.ShouldBe(DeleteStyle.SoftDelete); } }
public void set_the_version_member_through_the_fluent_interface() { using (var store = TestingDocumentStore.For(_ => { _.Schema.For <DocThatCouldBeVersioned>().VersionedWith(x => x.Revision); })) { store.Storage.MappingFor(typeof(DocThatCouldBeVersioned)) .VersionMember.Name.ShouldBe(nameof(DocThatCouldBeVersioned.Revision)); } }
public AsyncDaemonTestHelper() { _store = TestingDocumentStore.For(_ => { _.DatabaseSchemaName = "expected"; _.Events.DatabaseSchemaName = "expected"; _.Events.InlineProjections.AggregateStreamsWith <ActiveProject>(); _.Events.InlineProjections.TransformEvents(new CommitViewTransform()); }); }
public void can_fetch_the_function_ddl() { var store1 = TestingDocumentStore.For(_ => { _.DatabaseSchemaName = "other"; _.Schema.For <User>().Duplicate(x => x.UserName).Duplicate(x => x.Internal); }); store1.Tenancy.Default.EnsureStorageExists(typeof(User)); var upsert = store1.Storage.MappingFor(typeof(User)).As <DocumentMapping>().UpsertFunction; var functionBody = store1.Tenancy.Default.DbObjects.DefinitionForFunction(upsert); functionBody.Body.ShouldContain("mt_doc_user"); }
public void fetch_schema_objects_for_a_document_type_that_has_not_been_created_yet() { var store1 = TestingDocumentStore.For(_ => { _.DatabaseSchemaName = "public"; _.Schema.For <User>().Searchable(x => x.UserName).Searchable(x => x.Internal); }); var objects = store1.Schema.DbObjects.FindSchemaObjects(store1.Schema.MappingFor(typeof(User)).As <DocumentMapping>()); objects.HasNone().ShouldBeTrue(); objects.Table.ShouldBeNull(); objects.ActualIndices.Any().ShouldBeFalse(); objects.UpsertFunction.ShouldBeNull(); }
public void should_get_foreign_key_from_registry() { var storeOptions = new StoreOptions(); storeOptions.Schema.For <Issue>().ForeignKey <User>(i => i.OtherUserId); var store = TestingDocumentStore.For(_ => { _.Schema.For <Issue>().ForeignKey <User>(i => i.OtherUserId); }); store.Storage.MappingFor(typeof(Issue)) .As <DocumentMapping>() .ForeignKeys .ShouldContain(x => x.ColumnName == "other_user_id"); }
public void check_camel_case_serialized_property() { var store = TestingDocumentStore.For(_ => { _.UseDefaultSerialization(casing: Casing.CamelCase); }); var expressionWithSimpleProperty = new PatchExpression <Target>(null, _schema, new UnitOfWork(store, store.Tenancy.Default), store.Serializer); expressionWithSimpleProperty.Set(x => x.Color, Colors.Blue); expressionWithSimpleProperty.Patch["path"].ShouldBe("color"); var expressionWithNestedProperty = new PatchExpression <Target>(null, _schema, new UnitOfWork(store, store.Tenancy.Default), store.Serializer); expressionWithNestedProperty.Delete(x => x.Inner.AnotherString); expressionWithNestedProperty.Patch["path"].ShouldBe("inner.anotherString"); }
public void can_build_the_mt_stream_schema_objects_in_different_database_schema() { var store = TestingDocumentStore.For(_ => { _.Events.DatabaseSchemaName = "other"; }); store.Tenancy.Default.EnsureStorageExists(typeof(EventStream)); var schemaDbObjectNames = store.Tenancy.Default.DbObjects.Functions(); schemaDbObjectNames.ShouldContain("other.mt_append_event"); var schemaTableNames = store.Tenancy.Default.DbObjects.SchemaTables(); schemaTableNames.ShouldContain("other.mt_streams"); schemaTableNames.ShouldContain("other.mt_events"); schemaTableNames.ShouldContain("other.mt_event_progression"); }
public void should_allow_foreign_key_on_id_field() { var storeOptions = new StoreOptions(); var store = TestingDocumentStore.For(_ => { _.Schema.For <Foo>() .Identity(x => x.FooId); _.Schema.For <FooExtra>() .Identity(x => x.FooId) .ForeignKey <Foo>(x => x.FooId); }); store.Storage.MappingFor(typeof(FooExtra)) .As <DocumentMapping>() .ForeignKeys .ShouldContain(x => x.ColumnName == "foo_id"); }
public void can_build_the_event_schema_objects_in_a_separted_schema() { var store = TestingDocumentStore.For(_ => { // SAMPLE: override_schema_name_event_store _.Events.DatabaseSchemaName = "event_store"; // ENDSAMPLE }); store.Tenancy.Default.EnsureStorageExists(typeof(EventStream)); var schemaDbObjectNames = store.Tenancy.Default.DbObjects.Functions(); schemaDbObjectNames.ShouldContain("event_store.mt_append_event"); var schemaTableNames = store.Tenancy.Default.DbObjects.SchemaTables(); schemaTableNames.ShouldContain("event_store.mt_streams"); schemaTableNames.ShouldContain("event_store.mt_events"); }
public void do_not_remove_items_out_of_the_main_schema() { var store1 = TestingDocumentStore.DefaultSchema(); store1.BulkInsert(Target.GenerateRandomData(5).ToArray()); store1.BulkInsert(new[] { new User() }); store1.Tenancy.Default.DbObjects.DocumentTables().Any().ShouldBeTrue(); var store2 = TestingDocumentStore.For(_ => { _.DatabaseSchemaName = "other"; }); store2.BulkInsert(Target.GenerateRandomData(5).ToArray()); store2.BulkInsert(new[] { new User() }); store2.Tenancy.Default.DbObjects.DocumentTables().Any().ShouldBeTrue(); store1.Advanced.Clean.CompletelyRemoveAll(); store1.Tenancy.Default.DbObjects.DocumentTables().Any().ShouldBeFalse(); store2.Tenancy.Default.DbObjects.DocumentTables().Any().ShouldBeTrue(); }
public when_doing_a_schema_diff_with_no_changes_95_style() { var store1 = TestingDocumentStore.For(_ => { _.DatabaseSchemaName = Marten.StoreOptions.DefaultDatabaseSchemaName; _.Schema.For <User>().Duplicate(x => x.UserName).Duplicate(x => x.Internal); }); store1.Schema.EnsureStorageExists(typeof(User)); // Don't use TestingDocumentStore because it cleans everything upfront. store2 = DocumentStore.For(_ => { _.Connection(ConnectionSource.ConnectionString); _.DatabaseSchemaName = Marten.StoreOptions.DefaultDatabaseSchemaName; _.Schema.For <User>().Duplicate(x => x.UserName).Duplicate(x => x.Internal); }); mapping = store2.Schema.MappingFor(typeof(User)).As <DocumentMapping>(); diff = mapping.SchemaObjects.As <DocumentSchemaObjects>().CreateSchemaDiff(store2.Schema); }
public void no_patch_if_not_missing() { using (var store1 = TestingDocumentStore.For(_ => { _.Schema.For <Target>().Index(x => x.Number); })) { store1.Advanced.Clean.CompletelyRemoveAll(); store1.Tenancy.Default.EnsureStorageExists(typeof(Target)); } using (var store2 = DocumentStore.For(_ => { _.Connection(ConnectionSource.ConnectionString); _.Schema.For <Target>().Index(x => x.Number); })) { var patch = store2.Schema.ToPatch(typeof(Target)); patch.UpdateDDL.ShouldNotContain("mt_doc_target_idx_number"); } }
public void will_name_nested_class_table_with_containing_class_name_prefix_on_other_database_schema() { DocumentTable table1; DocumentTable table2; using (var store = TestingDocumentStore.For(_ => _.DatabaseSchemaName = "other")) { store.Tenancy.Default.StorageFor(typeof(Foo.Document)); store.Tenancy.Default.StorageFor(typeof(Bar.Document)); var documentTables = store.Tenancy.Default.DbObjects.DocumentTables(); documentTables.ShouldContain("other.mt_doc_foo_document"); documentTables.ShouldContain("other.mt_doc_bar_document"); table1 = store.TableSchema(typeof(Foo.Document)); table1.Identifier.Name.ShouldBe("mt_doc_foo_document"); table2 = store.TableSchema(typeof(Bar.Document)); table2.Identifier.Name.ShouldBe("mt_doc_bar_document"); } table2.Equals(table1).ShouldBeFalse(); }