public void RealDatabaseShouldNoOpToUnapplyMigrationsWhichDoNothingWhenUnapplied()
        {
            var tranection  = new TrannectionTraceOnly().BeginCapturing();
            var testSubject = new DatabaseRemote(tranection, DbEngine.None);

            testSubject.Unapply(MigrationEmpty);
            tranection.SqlExecuted.Should().BeEmpty();
        }
Example #2
0
        public void DatabaseShouldDisposeItsTranection()
        {
            var tracer      = new TrannectionTraceOnly();
            var testSubject = new DatabaseRemote(tracer, DbEngine.None);

            testSubject.Dispose();
            tracer.IsDisposed.Should().BeTrue();
        }
        public void RealDatabaseShouldUnapplyMigrationsByExecutingSql()
        {
            var tranection  = new TrannectionTraceOnly().BeginCapturing();
            var testSubject = new DatabaseRemote(tranection, DbEngine.None);

            testSubject.Unapply(Migration3);
            testSubject.Unapply(Migration2);
            tranection.SqlExecuted.Should().Equal(new[] { Migration3.Unapply, Migration2.Unapply });
        }
        public void ProductionRemoteDatabaseShouldNotRemoveTestData()
        {
            var tranection  = new TrannectionTraceOnly().BeginCapturing();
            var testSubject = new DatabaseRemote(tranection, DbEngine.None);

            testSubject.Unapply(Migration3);
            testSubject.Unapply(Migration2);
            tranection.SqlExecuted.Should().Equal(new[] { Migration3.Unapply, Migration2.Unapply });
        }
Example #5
0
        public void DatabaseShouldCommitItsTranection()
        {
            var tracer = new TrannectionTraceOnly();

            using (var testSubject = new DatabaseRemote(tracer, DbEngine.None))
            {
                testSubject.Commit();
                tracer.IsCommitted.Should().BeTrue();
            }
        }
        public void ShouldNeverInsertTestDataWhichIsNoOp()
        {
            var tranection  = new TrannectionTraceOnly().BeginCapturing();
            var testSubject = new DatabaseRemote(tranection, DbEngine.None)
            {
                IsTestDatabase = true
            };

            testSubject.Apply(MigrationWithoutTestData);
            tranection.SqlExecuted.Should().Equal(new[] { MigrationWithoutTestData.Apply });
        }
Example #7
0
        public void DatabaseShouldCreateATranection()
        {
            const string connectionString = "some fake connection string;";

            using (var testSubject = new DatabaseRemote(DbEngine.None, connectionString))
            {
                testSubject.Tranection.Should().BeOfType <DbTranection>();
                testSubject.Tranection.Should().BeEquivalentTo(
                    new { IsOpen = false, ConnectionString = ExpectedConnectionString(connectionString) },
                    options => options.ExcludingMissingMembers());
            }
        }
Example #8
0
        public void DatabaseShouldKnowItsCurrentVersion()
        {
            var tracer      = new TrannectionTraceOnly();
            var testSubject = new DatabaseRemote(tracer, DbEngine.SqlLite);

            tracer.ExecuteScalarHandler =
                sql =>
            {
                sql.Should().Be(DbEngine.SqlLite.RequestVersionSql);
                return(6);
            };
            testSubject.CurrentVersion.Result.Should().Be(6);
        }
        public void NonProductionRemoteDatabaseShouldApplyTestData()
        {
            var tranection  = new TrannectionTraceOnly().BeginCapturing();
            var testSubject = new DatabaseRemote(tranection, DbEngine.None)
            {
                IsTestDatabase = true
            };

            testSubject.Apply(Migration2);
            testSubject.Apply(Migration3);
            tranection.SqlExecuted.Should().Equal(new[]
                                                  { Migration2.Apply, Migration2.InsertTestData, Migration3.Apply, Migration3.InsertTestData });
        }
Example #10
0
        public void ShouldBeAbleToGoToNewVersion()
        {
            var tracer        = new TrannectionTraceOnly();
            var testSubject   = new DatabaseRemote(tracer, DbEngine.None);
            var hasBeenCalled = false;

            tracer.ExecuteNonQueryHandler =
                sql =>
            {
                sql.Should().Be(UpdateToVersion9Sql);
                hasBeenCalled = true;
            };
            testSubject.SetCurrentVersionTo(9).Wait();
            hasBeenCalled.Should().BeTrue();
        }
        public void RemoteDatabaseShouldDefaultToBeProductionDatabase()
        {
            var db = new DatabaseRemote(new TrannectionTraceOnly(), DbEngine.None);

            db.IsTestDatabase.Should().BeFalse();
        }