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();
}