public async Task BaseOrchestrator_GetSchema_NonExistingColumns_ShouldFail() { var dbName = HelperDatabase.GetRandomName("tcp_lo_"); await HelperDatabase.CreateDatabaseAsync(ProviderType.Sql, dbName, true); var cs = HelperDatabase.GetConnectionString(ProviderType.Sql, dbName); var sqlProvider = new SqlSyncProvider(cs); var ctx = new AdventureWorksContext((dbName, ProviderType.Sql, sqlProvider), true, false); await ctx.Database.EnsureCreatedAsync(); var options = new SyncOptions(); // Create a bad setup with a non existing table var tables = new string[] { "Customer", "Address", "CustomerAddress" }; var setup = new SyncSetup(tables); setup.Tables["Customer"].Columns.AddRange(new string[] { "FirstName", "LastName", "CompanyName", "BADCOLUMN" }); var localOrchestrator = new LocalOrchestrator(sqlProvider, options, setup); var se = await Assert.ThrowsAsync <SyncException>(async() => { var schema = await localOrchestrator.GetSchemaAsync(); }); Assert.Equal(SyncStage.SchemaReading, se.SyncStage); Assert.Equal(SyncSide.ClientSide, se.Side); Assert.Equal("MissingColumnException", se.TypeName); HelperDatabase.DropDatabase(ProviderType.Sql, dbName); }
public async Task BaseOrchestrator_GetSchema_NonExistingTables_ShouldFail() { var dbName = HelperDatabase.GetRandomName("tcp_lo_"); await HelperDatabase.CreateDatabaseAsync(ProviderType.Sql, dbName, true); var cs = HelperDatabase.GetConnectionString(ProviderType.Sql, dbName); var sqlProvider = new SqlSyncProvider(cs); var ctx = new AdventureWorksContext((dbName, ProviderType.Sql, sqlProvider), true, false); await ctx.Database.EnsureCreatedAsync(); var options = new SyncOptions(); // Create a bad setup with a non existing table var tables = new string[] { "SalesLT.ProductCategory", "SalesLT.ProductModel", "SalesLT.Product", "Employee", "Customer", "Address", "CustomerAddress", "EmployeeAddress", "SalesLT.SalesOrderHeader", "SalesLT.SalesOrderDetail", "dbo.Sql", "Posts", "Tags", "PostTag", "PricesList", "PricesListCategory", "PricesListDetail", "WRONGTABLE" }; var setup = new SyncSetup(tables); var localOrchestrator = new LocalOrchestrator(sqlProvider, options, setup); var se = await Assert.ThrowsAsync <SyncException>(async() => { var schema = await localOrchestrator.GetSchemaAsync(); }); Assert.Equal(SyncStage.SchemaReading, se.SyncStage); Assert.Equal(SyncSide.ClientSide, se.Side); Assert.Equal("MissingTableException", se.TypeName); HelperDatabase.DropDatabase(ProviderType.Sql, dbName); }
public async Task BaseOrchestrator_GetSchema_SetupColumnsDefined_ShouldReturn_SchemaWithSetupColumnsOnly() { var dbName = HelperDatabase.GetRandomName("tcp_lo_"); await HelperDatabase.CreateDatabaseAsync(ProviderType.Sql, dbName, true); var cs = HelperDatabase.GetConnectionString(ProviderType.Sql, dbName); var sqlProvider = new SqlSyncProvider(cs); var ctx = new AdventureWorksContext((dbName, ProviderType.Sql, sqlProvider), true, false); await ctx.Database.EnsureCreatedAsync(); var options = new SyncOptions(); // Create a bad setup with a non existing table var tables = new string[] { "Customer", "Address", "CustomerAddress" }; var setup = new SyncSetup(tables); setup.Tables["Customer"].Columns.AddRange(new string[] { "CustomerID", "FirstName", "LastName", "CompanyName" }); var localOrchestrator = new LocalOrchestrator(sqlProvider, options, setup); var schema = await localOrchestrator.GetSchemaAsync(); Assert.Equal(SyncStage.SchemaReading, localOrchestrator.GetContext().SyncStage); Assert.Equal(3, schema.Tables.Count); // Only 4 columns shoud be part of Customer table Assert.Equal(4, schema.Tables["Customer"].Columns.Count); Assert.Equal(9, schema.Tables["Address"].Columns.Count); Assert.Equal(5, schema.Tables["CustomerAddress"].Columns.Count); HelperDatabase.DropDatabase(ProviderType.Sql, dbName); }
public async Task BaseOrchestrator_GetSchema_ShouldReturnSchema() { var dbName = HelperDatabase.GetRandomName("tcp_lo_"); await HelperDatabase.CreateDatabaseAsync(ProviderType.Sql, dbName, true); var cs = HelperDatabase.GetConnectionString(ProviderType.Sql, dbName); var sqlProvider = new SqlSyncProvider(cs); var ctx = new AdventureWorksContext((dbName, ProviderType.Sql, sqlProvider), true, false); await ctx.Database.EnsureCreatedAsync(); var scopeName = "scope"; var options = new SyncOptions(); var setup = new SyncSetup(this.Tables); var onSchemaRead = false; var onSchemaReading = false; var localOrchestrator = new LocalOrchestrator(sqlProvider, options, setup, scopeName); localOrchestrator.OnSchemaLoading(args => { onSchemaReading = true; }); localOrchestrator.OnSchemaLoaded(args => { Assert.IsType <SchemaLoadedArgs>(args); Assert.Equal(SyncStage.SchemaReading, args.Context.SyncStage); Assert.Equal(scopeName, args.Context.ScopeName); Assert.NotNull(args.Connection); Assert.Null(args.Transaction); Assert.Equal(ConnectionState.Open, args.Connection.State); Assert.Equal(17, args.Schema.Tables.Count); onSchemaRead = true; }); AssertConnectionAndTransaction(localOrchestrator, SyncStage.SchemaReading); var schema = await localOrchestrator.GetSchemaAsync(); Assert.NotNull(schema); Assert.Equal(SyncStage.SchemaReading, localOrchestrator.GetContext().SyncStage); Assert.Equal(17, schema.Tables.Count); Assert.True(onSchemaRead); Assert.True(onSchemaReading); HelperDatabase.DropDatabase(ProviderType.Sql, dbName); }
public async Task BaseOrchestrator_GetSchema_CancellationToken_ShouldInterrupt() { var dbName = HelperDatabase.GetRandomName("tcp_lo_"); await HelperDatabase.CreateDatabaseAsync(ProviderType.Sql, dbName, true); var cs = HelperDatabase.GetConnectionString(ProviderType.Sql, dbName); var sqlProvider = new SqlSyncProvider(cs); var ctx = new AdventureWorksContext((dbName, ProviderType.Sql, sqlProvider), true, false); await ctx.Database.EnsureCreatedAsync(); var options = new SyncOptions(); var setup = new SyncSetup(this.Tables); var localOrchestrator = new LocalOrchestrator(sqlProvider, options, setup); using var cts = new CancellationTokenSource(); localOrchestrator.OnConnectionOpen(args => { Assert.Equal(SyncStage.SchemaReading, args.Context.SyncStage); Assert.IsType <ConnectionOpenedArgs>(args); Assert.NotNull(args.Connection); Assert.Null(args.Transaction); Assert.Equal(ConnectionState.Open, args.Connection.State); cts.Cancel(); }); var se = await Assert.ThrowsAsync <SyncException>(async() => { var schema = await localOrchestrator.GetSchemaAsync(cancellationToken: cts.Token); }); Assert.Equal(SyncStage.SchemaReading, se.SyncStage); Assert.Equal(SyncSide.ClientSide, se.Side); Assert.Equal("OperationCanceledException", se.TypeName); HelperDatabase.DropDatabase(ProviderType.Sql, dbName); }
public async Task Table_Create_All() { var dbName = HelperDatabase.GetRandomName("tcp_lo_"); await HelperDatabase.CreateDatabaseAsync(ProviderType.Sql, dbName, true); var cs = HelperDatabase.GetConnectionString(ProviderType.Sql, dbName); var sqlProvider = new SqlSyncProvider(cs); var ctx = new AdventureWorksContext((dbName, ProviderType.Sql, sqlProvider), true, false); await ctx.Database.EnsureCreatedAsync(); var options = new SyncOptions(); var setup = new SyncSetup(new string[] { "SalesLT.ProductCategory", "SalesLT.ProductModel", "SalesLT.Product", "dbo.Sql", "Posts" }); var localOrchestrator = new LocalOrchestrator(sqlProvider, options, setup); var schema = await localOrchestrator.GetSchemaAsync(); // new empty db dbName = HelperDatabase.GetRandomName("tcp_lo_"); await HelperDatabase.CreateDatabaseAsync(ProviderType.Sql, dbName, true); cs = HelperDatabase.GetConnectionString(ProviderType.Sql, dbName); sqlProvider = new SqlSyncProvider(cs); localOrchestrator = new LocalOrchestrator(sqlProvider, options, setup); var onCreating = 0; var onCreated = 0; var onDropping = 0; var onDropped = 0; localOrchestrator.OnTableCreating(ttca => onCreating++); localOrchestrator.OnTableCreated(ttca => onCreated++); localOrchestrator.OnTableDropping(ttca => onDropping++); localOrchestrator.OnTableDropped(ttca => onDropped++); await localOrchestrator.CreateTablesAsync(schema); Assert.Equal(5, onCreating); Assert.Equal(5, onCreated); Assert.Equal(0, onDropping); Assert.Equal(0, onDropped); onCreating = 0; onCreated = 0; onDropping = 0; onDropped = 0; await localOrchestrator.CreateTablesAsync(schema); Assert.Equal(0, onCreating); Assert.Equal(0, onCreated); Assert.Equal(0, onDropping); Assert.Equal(0, onDropped); await localOrchestrator.CreateTablesAsync(schema, true); Assert.Equal(5, onCreating); Assert.Equal(5, onCreated); Assert.Equal(5, onDropping); Assert.Equal(5, onDropped); HelperDatabase.DropDatabase(ProviderType.Sql, dbName); }
public async Task LocalOrchestrator_MultipleScopes_Check_Metadatas_Are_Deleted() { var dbName = HelperDatabase.GetRandomName("tcp_lo_"); await HelperDatabase.CreateDatabaseAsync(ProviderType.Sql, dbName, true); var cs = HelperDatabase.GetConnectionString(ProviderType.Sql, dbName); var sqlProvider = new SqlSyncProvider(cs); var ctx = new AdventureWorksContext((dbName, ProviderType.Sql, sqlProvider), true, false); await ctx.Database.EnsureCreatedAsync(); var options = new SyncOptions(); var localOrchestrator = new LocalOrchestrator(sqlProvider, options); var setup = new SyncSetup(this.Tables); var setup2 = new SyncSetup(this.Tables); setup2.Filters.Add("Customer", "EmployeeID"); var schema = await localOrchestrator.GetSchemaAsync(setup); var localScopeInfo1 = await localOrchestrator.GetClientScopeInfoAsync(); var localScopeInfo2 = await localOrchestrator.GetClientScopeInfoAsync("A"); var serverScope1 = new ServerScopeInfo { Name = localScopeInfo1.Name, Schema = schema, Setup = setup, Version = localScopeInfo1.Version }; var serverScope2 = new ServerScopeInfo { Name = localScopeInfo2.Name, Schema = schema, Setup = setup2, Version = localScopeInfo2.Version }; // Provision two scopes (already tested in previous test) localScopeInfo1 = await localOrchestrator.ProvisionAsync(serverScope1); localScopeInfo2 = await localOrchestrator.ProvisionAsync(serverScope2); Assert.NotNull(localScopeInfo1.Setup); Assert.NotNull(localScopeInfo1.Schema); Assert.NotNull(localScopeInfo2.Setup); Assert.NotNull(localScopeInfo2.Schema); // Deprovision await localOrchestrator.DeprovisionAsync("A"); foreach (var table in localScopeInfo1.Setup.Tables) { var tableName = table.TableName; var schemaName = table.SchemaName; foreach (var objectSpType in Enum.GetValues(typeof(Builders.DbStoredProcedureType))) { var spType = (Builders.DbStoredProcedureType)objectSpType; var exists1 = await localOrchestrator.ExistStoredProcedureAsync( localScopeInfo1, tableName, schemaName, spType); var exists2 = await localOrchestrator.ExistStoredProcedureAsync( localScopeInfo2, tableName, schemaName, spType); if (spType == Builders.DbStoredProcedureType.SelectChangesWithFilters || spType == Builders.DbStoredProcedureType.SelectInitializedChangesWithFilters) { Assert.False(exists1); } else { Assert.True(exists1); } Assert.False(exists2); } foreach (var objectSpType in Enum.GetValues(typeof(Builders.DbTriggerType))) { var trigType = (Builders.DbTriggerType)objectSpType; var existsTrig1 = await localOrchestrator.ExistTriggerAsync(localScopeInfo1, tableName, schemaName, trigType); var existsTrig2 = await localOrchestrator.ExistTriggerAsync(localScopeInfo2, tableName, schemaName, trigType); Assert.False(existsTrig1); Assert.False(existsTrig2); } var trackTableExists1 = await localOrchestrator.ExistTrackingTableAsync(localScopeInfo1, tableName, schemaName); var trackTableExists2 = await localOrchestrator.ExistTrackingTableAsync(localScopeInfo2, tableName, schemaName); // Tracking table are still existing for others scopes Assert.True(trackTableExists1); Assert.True(trackTableExists2); } // Deprovision await localOrchestrator.DeprovisionAsync(); foreach (var table in localScopeInfo1.Setup.Tables) { var tableName = table.TableName; var schemaName = table.SchemaName; foreach (var objectSpType in Enum.GetValues(typeof(Builders.DbStoredProcedureType))) { var spType = (Builders.DbStoredProcedureType)objectSpType; var exists1 = await localOrchestrator.ExistStoredProcedureAsync( localScopeInfo1, tableName, schemaName, spType); var exists2 = await localOrchestrator.ExistStoredProcedureAsync( localScopeInfo2, tableName, schemaName, spType); Assert.False(exists1); Assert.False(exists2); } } HelperDatabase.DropDatabase(ProviderType.Sql, dbName); }
public async Task BaseOrchestrator_Provision_Check_Interceptors() { var dbName = HelperDatabase.GetRandomName("tcp_lo_"); await HelperDatabase.CreateDatabaseAsync(ProviderType.Sql, dbName, true); var cs = HelperDatabase.GetConnectionString(ProviderType.Sql, dbName); var sqlProvider = new SqlSyncProvider(cs); var ctx = new AdventureWorksContext((dbName, ProviderType.Sql, sqlProvider), true, false); await ctx.Database.EnsureCreatedAsync(); var scopeName = "scope"; var options = new SyncOptions(); // Options set here and we must check if TableBuilder has correct version options.UseBulkOperations = true; var setup = new SyncSetup(new string[] { "SalesLT.Product" }); var onTableProvisioned = false; var onTableProvisioning = false; var onDatabaseProvisioned = false; var onDatabaseProvisioning = false; var provision = SyncProvision.Table | SyncProvision.TrackingTable | SyncProvision.StoredProcedures | SyncProvision.Triggers; var localOrchestrator = new LocalOrchestrator(sqlProvider, options, setup, scopeName); // Assuming GetSchemaAsync() is correct // make the GetSchema call, before registrating interceptors var schema = await localOrchestrator.GetSchemaAsync(); localOrchestrator.OnDatabaseProvisioning(args => { Assert.IsType <DatabaseProvisioningArgs>(args); Assert.Equal(SyncStage.Provisioning, args.Context.SyncStage); Assert.Equal(scopeName, args.Context.ScopeName); Assert.NotNull(args.Connection); Assert.NotNull(args.Transaction); Assert.Equal(ConnectionState.Open, args.Connection.State); Assert.Equal(provision, args.Provision); Assert.Equal(schema, args.Schema); onDatabaseProvisioning = true; }); localOrchestrator.OnDatabaseProvisioned(args => { Assert.IsType <DatabaseProvisionedArgs>(args); Assert.Equal(SyncStage.Provisioned, args.Context.SyncStage); Assert.Equal(scopeName, args.Context.ScopeName); Assert.NotNull(args.Connection); Assert.Null(args.Transaction); Assert.Equal(ConnectionState.Closed, args.Connection.State); Assert.Equal(provision, args.Provision); Assert.Equal(schema, args.Schema); onDatabaseProvisioned = true; }); localOrchestrator.OnTableProvisioning(args => { Assert.IsType <TableProvisioningArgs>(args); Assert.Equal(SyncStage.Provisioning, args.Context.SyncStage); Assert.Equal(scopeName, args.Context.ScopeName); Assert.NotNull(args.Connection); Assert.NotNull(args.Transaction); Assert.Equal(ConnectionState.Open, args.Connection.State); Assert.True(args.TableBuilder.UseBulkProcedures); Assert.False(args.TableBuilder.UseChangeTracking); Assert.NotNull(args.TableBuilder.TableDescription); Assert.Equal("SalesLT.Product", args.TableBuilder.TableDescription.GetFullName()); onTableProvisioning = true; }); localOrchestrator.OnTableProvisioned(args => { Assert.IsType <TableProvisionedArgs>(args); // We are still provisioning the tables Assert.Equal(SyncStage.Provisioning, args.Context.SyncStage); Assert.Equal(scopeName, args.Context.ScopeName); Assert.NotNull(args.Connection); Assert.NotNull(args.Transaction); Assert.Equal(ConnectionState.Open, args.Connection.State); Assert.NotNull(args.SchemaTable); Assert.Equal("SalesLT.Product", args.SchemaTable.GetFullName()); onTableProvisioned = true; }); AssertConnectionAndTransaction(localOrchestrator, SyncStage.Provisioning, SyncStage.Provisioned); await localOrchestrator.ProvisionAsync(schema, provision); Assert.Equal(SyncStage.Provisioned, localOrchestrator.GetContext().SyncStage); Assert.True(onTableProvisioned); Assert.True(onTableProvisioning); Assert.True(onDatabaseProvisioned); Assert.True(onDatabaseProvisioning); HelperDatabase.DropDatabase(ProviderType.Sql, dbName); }
public async Task Scenario_Using_ExistingClientDatabase_ProvisionDeprovision_WithoutAccessToServerSide(SyncOptions options) { // This test works only if we have the same exact provider on both sides // create client orchestrator that is the same as server var clientDatabaseName = HelperDatabase.GetRandomName("tcpfilt_cli_"); var clientProvider = this.CreateProvider(this.ServerType, clientDatabaseName); var client = (clientDatabaseName, Server.ProviderType, Provider : clientProvider); // create a client schema without seeding await this.EnsureDatabaseSchemaAndSeedAsync(client, false, UseFallbackSchema); // Since we don't have access to remote orchestrator, // we can simulate a server scope var localOrchestrator = new LocalOrchestrator(client.Provider, options); // Get the local scope var localScopeInfo = await localOrchestrator.GetClientScopeInfoAsync(); // getting local scope did not get the schema var schema = await localOrchestrator.GetSchemaAsync(this.FilterSetup); // getting local schema from these provider will not fill the schema name for each table // and we need the exact same name even if it's not used on client if (client.ProviderType == ProviderType.MySql || client.ProviderType == ProviderType.MariaDB || client.ProviderType == ProviderType.Sqlite) { foreach (var table in schema.Tables) { var setupTable = this.FilterSetup.Tables.First(t => t.TableName == table.TableName); table.SchemaName = setupTable.SchemaName; } } // Simulate a server scope var serverScope = new ServerScopeInfo { Name = localScopeInfo.Name, Schema = schema, Setup = this.FilterSetup, Version = localScopeInfo.Version }; // just check interceptor var onTableCreatedCount = 0; localOrchestrator.OnTableCreated(args => onTableCreatedCount++); // Provision the database with all tracking tables, stored procedures, triggers and scope var clientScope = await localOrchestrator.ProvisionAsync(serverScope); //-------------------------- // ASSERTION //-------------------------- // check if scope table is correctly created var scopeInfoTableExists = await localOrchestrator.ExistScopeInfoTableAsync(clientScope.Name, DbScopeType.Client); Assert.True(scopeInfoTableExists); // get the db manager foreach (var setupTable in this.FilterSetup.Tables) { Assert.True(await localOrchestrator.ExistTrackingTableAsync(clientScope, setupTable.TableName, setupTable.SchemaName)); Assert.True(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Delete)); Assert.True(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Insert)); Assert.True(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Update)); if (client.ProviderType == ProviderType.Sql) { Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkDeleteRows)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkTableType)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkUpdateRows)); } Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.DeleteMetadata)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.DeleteRow)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.Reset)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectChanges)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectInitializedChanges)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectRow)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.UpdateRow)); // Filters here Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectChangesWithFilters)); Assert.True(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectInitializedChangesWithFilters)); } //localOrchestrator.OnTableProvisioned(null); //// Deprovision the database with all tracking tables, stored procedures, triggers and scope await localOrchestrator.DeprovisionAsync(SyncProvision.StoredProcedures | SyncProvision.Triggers | SyncProvision.ClientScope | SyncProvision.TrackingTable); // check if scope table is correctly created scopeInfoTableExists = await localOrchestrator.ExistScopeInfoTableAsync(clientScope.Name, DbScopeType.Client); Assert.False(scopeInfoTableExists); // get the db manager foreach (var setupTable in this.FilterSetup.Tables) { Assert.False(await localOrchestrator.ExistTrackingTableAsync(clientScope, setupTable.TableName, setupTable.SchemaName)); Assert.False(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Delete)); Assert.False(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Insert)); Assert.False(await localOrchestrator.ExistTriggerAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbTriggerType.Update)); if (client.ProviderType == ProviderType.Sql) { Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkDeleteRows)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkTableType)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.BulkUpdateRows)); } Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.DeleteMetadata)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.DeleteRow)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.Reset)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectChanges)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectInitializedChanges)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectRow)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.UpdateRow)); // check filters are deleted Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectChangesWithFilters)); Assert.False(await localOrchestrator.ExistStoredProcedureAsync(clientScope, setupTable.TableName, setupTable.SchemaName, DbStoredProcedureType.SelectInitializedChangesWithFilters)); } }