private static bool AllMigrationsApplied(this Microsoft.EntityFrameworkCore.DbContext context)
        {
            var applied = context.GetService <IHistoryRepository>()
                          .GetAppliedMigrations()
                          .Select(m => m.MigrationId);

            var total = context.GetService <IMigrationsAssembly>()
                        .Migrations
                        .Select(m => m.Key);

            return(!total.Except(applied).Any());
        }
        protected virtual void DiffSnapshot(ModelSnapshot snapshot, DbContext context)
        {
            var dependencies          = context.GetService <ProviderConventionSetBuilderDependencies>();
            var typeMappingConvention = new TypeMappingConvention(dependencies);

            typeMappingConvention.ProcessModelFinalizing(((IConventionModel)snapshot.Model).Builder, null);

            var relationalModelConvention = new RelationalModelConvention();
            var sourceModel = relationalModelConvention.ProcessModelFinalized(snapshot.Model);

            var modelDiffer = context.GetService <IMigrationsModelDiffer>();
            var operations  = modelDiffer.GetDifferences(((IMutableModel)sourceModel).FinalizeModel(), context.Model);

            Assert.Equal(0, operations.Count);
        }
        public void SaveChanges_calls_DetectChanges()
        {
            var services = new ServiceCollection()
                           .AddScoped <IStateManager, FakeStateManager>()
                           .AddScoped <IChangeDetector, FakeChangeDetector>();

            var model           = new ModelBuilder(new ConventionSet()).Entity <User>().Metadata.Model;
            var serviceProvider = InMemoryTestHelpers.Instance.CreateServiceProvider(services);

            using (var context = new DbContext(
                       new DbContextOptionsBuilder()
                       .UseInternalServiceProvider(serviceProvider)
                       .UseInMemoryDatabase(Guid.NewGuid().ToString())
                       .UseModel(model)
                       .Options))
            {
                var changeDetector = (FakeChangeDetector)context.GetService <IChangeDetector>();

                Assert.False(changeDetector.DetectChangesCalled);

                context.SaveChanges();

                Assert.True(changeDetector.DetectChangesCalled);
            }
        }
Beispiel #4
0
        public static int SubmitSaveChanges(this DbContext dbContext,
                                            bool acceptAllChangesOnSuccess = true)
        {
            dbContext.NotNull(nameof(dbContext));

            CheckDisposed(dbContext);

            var dependencies = dbContext.GetService <IDbContextDependencies>();

            dependencies.UpdateLogger.SaveChangesStarting(dbContext);

            TryDetectChanges(dbContext);

            try
            {
                var entitiesSaved = dependencies.StateManager.SaveChanges(acceptAllChangesOnSuccess);

                dependencies.UpdateLogger.SaveChangesCompleted(dbContext, entitiesSaved);

                return(entitiesSaved);
            }
            catch (DbUpdateConcurrencyException exception)
            {
                dependencies.UpdateLogger.OptimisticConcurrencyException(dbContext, exception);

                throw;
            }
            catch (Exception exception)
            {
                dependencies.UpdateLogger.SaveChangesFailed(dbContext, exception);

                throw;
            }
        }
        /// <summary>
        ///     Creates a proxy instance for an entity type if proxy creation has been turned on.
        /// </summary>
        /// <param name="context"> The <see cref="DbContext" />. </param>
        /// <param name="entityType"> The entity type for which a proxy is needed. </param>
        /// <param name="constructorArguments"> Arguments to pass to the entity type constructor. </param>
        /// <returns> The proxy instance. </returns>
        public static object CreateProxy(
            [NotNull] this DbContext context,
            [NotNull] Type entityType,
            [NotNull] params object[] constructorArguments)
        {
            Check.NotNull(context, nameof(context));
            Check.NotNull(entityType, nameof(entityType));
            Check.NotNull(constructorArguments, nameof(constructorArguments));

            var options = context.GetService <IDbContextOptions>().FindExtension <ProxiesOptionsExtension>();

            if (options?.UseLazyLoadingProxies != true)
            {
                throw new InvalidOperationException(ProxiesStrings.ProxiesNotEnabled(entityType.ShortDisplayName()));
            }

            return(context.GetService <IProxyFactory>().Create(context, entityType, constructorArguments));
        }
        public static bool InitialMigrationApplied(this Microsoft.EntityFrameworkCore.DbContext context)
        {
            var allAppliedMigrations = context.GetService <IHistoryRepository>()
                                       .GetAppliedMigrations()
                                       .Select(x => x.MigrationId)
                                       .ToArray();

            return(allAppliedMigrations.Any(x => x.EndsWith(InitialMigrationId)) &&
                   !allAppliedMigrations.Contains(SeedInitialDataMigrationId));
        }
        protected virtual void DiffSnapshot(ModelSnapshot snapshot, DbContext context)
        {
            var sourceModel = snapshot.Model;
            var targetModel = context.Model;

            var modelDiffer = context.GetService <IMigrationsModelDiffer>();
            var operations  = modelDiffer.GetDifferences(sourceModel, targetModel);

            Assert.Equal(0, operations.Count);
        }
 /// <summary>
 ///     Creates a new instance of <see cref="SqlServerRetryingExecutionStrategy" />.
 /// </summary>
 /// <param name="context"> The context on which the operations will be invoked. </param>
 /// <param name="maxRetryCount"> The maximum number of retry attempts. </param>
 /// <param name="maxRetryDelay"> The maximum delay in milliseconds between retries. </param>
 /// <param name="errorNumbersToAdd"> Additional SQL error numbers that should be considered transient. </param>
 public SqlServerRetryingExecutionStrategy(
     [NotNull] DbContext context,
     int maxRetryCount,
     TimeSpan maxRetryDelay,
     [CanBeNull] ICollection <int> errorNumbersToAdd)
     : this(new ExecutionStrategyContext(
                context, context.GetService <IDbContextServices>().LoggerFactory.CreateLogger <IExecutionStrategy>()),
            maxRetryCount, maxRetryDelay, errorNumbersToAdd)
 {
 }
        private static string CreateDebugView(DbContext context)
        {
#if CORE50
            var model = context.Model;
            return(model.AsModel().DebugView.LongView);
#elif CORE60
            return(context.GetService <IDesignTimeModel>().Model.ToDebugString(MetadataDebugStringOptions.LongDefault));
#else
            var model = context.Model;
            return(model.AsModel().DebugView.View);
#endif
        }
 /// <summary>
 ///     Creates a new instance of <see cref="SqlServerRetryingExecutionStrategy" />.
 /// </summary>
 /// <param name="context"> The context on which the operations will be invoked. </param>
 /// <param name="maxRetryCount"> The maximum number of retry attempts. </param>
 /// <param name="maxRetryDelay"> The maximum delay in milliseconds between retries. </param>
 /// <param name="errorNumbersToAdd"> Additional SQL error numbers that should be considered transient. </param>
 public SqlServerRetryingExecutionStrategy(
     [NotNull] DbContext context,
     int maxRetryCount,
     TimeSpan maxRetryDelay,
     [CanBeNull] ICollection <int> errorNumbersToAdd)
     : this(new ExecutionStrategyContext(
                context.GetService <ExecutionStrategyContextDependencies>()),
            maxRetryCount,
            maxRetryDelay,
            errorNumbersToAdd)
 {
 }
        protected virtual void DiffSnapshot(ModelSnapshot snapshot, DbContext context)
        {
            var sourceModel = snapshot.Model;
            var targetModel = context.Model;

            var typeMapper = context.GetService <IRelationalTypeMappingSource>();

            foreach (var property in sourceModel.GetEntityTypes().SelectMany(e => e.GetDeclaredProperties()))
            {
                Assert.NotNull(typeMapper.FindMapping(property));
            }

            foreach (var property in targetModel.GetEntityTypes().SelectMany(e => e.GetDeclaredProperties()))
            {
                Assert.NotNull(typeMapper.FindMapping(property));
            }

            var modelDiffer = context.GetService <IMigrationsModelDiffer>();
            var operations  = modelDiffer.GetDifferences(sourceModel, targetModel);

            Assert.Equal(0, operations.Count);
        }
        public void It_disposes_scope()
        {
            var fakeServiceProvider = new FakeServiceProvider();
            var context             = new DbContext(
                new DbContextOptionsBuilder().UseInternalServiceProvider(fakeServiceProvider).UseInMemoryDatabase(Guid.NewGuid().ToString()).Options);

            var scopeService = Assert.IsType <FakeServiceProvider.FakeServiceScope>(context.GetService <IServiceScopeFactory>().CreateScope());

            Assert.False(scopeService.Disposed);

            context.Dispose();

            Assert.True(scopeService.Disposed);

            Assert.Throws <ObjectDisposedException>(() => ((IInfrastructure <IServiceProvider>)context).Instance);
        }
Beispiel #13
0
        protected virtual async Task GiveMeSomeTimeAsync(DbContext db)
        {
            var stillExists = true;

            for (var i = 0; stillExists && i < 10; i++)
            {
                try
                {
                    await Task.Delay(500);

                    stillExists = await db.GetService <IRelationalDatabaseCreator>().ExistsAsync();
                }
                catch
                {
                }
            }
        }
Beispiel #14
0
        // Database deletion can happen as async file operation and SQLClient
        // doesn't account for this, so give some time for it to happen on slow C.I. machines
        protected virtual void GiveMeSomeTime(DbContext db)
        {
            var stillExists = true;

            for (var i = 0; stillExists && i < 10; i++)
            {
                try
                {
                    Thread.Sleep(500);

                    stillExists = db.GetService <IRelationalDatabaseCreator>().Exists();
                }
                catch
                {
                }
            }
        }
Beispiel #15
0
        public static async Task <int> SubmitSaveChangesAsync(this DbContext dbContext,
                                                              bool acceptAllChangesOnSuccess = true, CancellationToken cancellationToken = default)
        {
            dbContext.NotNull(nameof(dbContext));

            CheckDisposed(dbContext);

            var dependencies = dbContext.GetService <IDbContextDependencies>();

            dependencies.UpdateLogger.SaveChangesStarting(dbContext);

            TryDetectChanges(dbContext);

            try
            {
                var entitiesSaved = await dependencies.StateManager
                                    .SaveChangesAsync(acceptAllChangesOnSuccess, cancellationToken)
                                    .ConfigureAwait();

                dependencies.UpdateLogger.SaveChangesCompleted(dbContext, entitiesSaved);

                return(entitiesSaved);
            }
            catch (DbUpdateConcurrencyException exception)
            {
                dependencies.UpdateLogger.OptimisticConcurrencyException(dbContext, exception);

                throw;
            }
            catch (Exception exception)
            {
                dependencies.UpdateLogger.SaveChangesFailed(dbContext, exception);

                throw;
            }
        }