Merge pull request #80 from msallin/#76

#76: Ability to use SQLite.CodeFirst with :memory:

Author: msallin

SQLite.CodeFirst.Console/FootballDbContext.cs

@@ -1,11 +1,23 @@
-using System.Data.Entity;
+using System.Data.Common;
+using System.Data.Entity;
 
 namespace SQLite.CodeFirst.Console
 {
     public class FootballDbContext : DbContext
     {
-        public FootballDbContext()
-            : base("footballDb")
+        public FootballDbContext(string nameOrConnectionString)
+            : base(nameOrConnectionString)
+        {
+            Configure();
+        }
+
+        public FootballDbContext(DbConnection connection, bool contextOwnsConnection)
+            : base(connection, contextOwnsConnection)
+        {
+            Configure();
+        }
+
+        private void Configure()
         {
             Configuration.ProxyCreationEnabled = true;
             Configuration.LazyLoadingEnabled = true;

SQLite.CodeFirst.Console/FootballDbInitializer.cs

@@ -1,4 +1,3 @@
-using System.Collections.Generic;
 using System.Data.Entity;
 using SQLite.CodeFirst.Console.Entity;
 
@@ -12,42 +11,7 @@ public FootballDbInitializer(DbModelBuilder modelBuilder)
 
         protected override void Seed(FootballDbContext context)
         {
-            context.Set<Team>().Add(new Team
-            {
-                Name = "YB",
-                Coach = new Coach
-                {
-                    City = "Zürich",
-                    FirstName = "Masssaman",
-                    LastName = "Nachn",
-                    Street = "Testingstreet 844"
-                },
-                Players = new List<Player>
-                {
-                    new Player
-                    {
-                        City = "Bern",
-                        FirstName = "Marco",
-                        LastName = "Bürki",
-                        Street = "Wunderstrasse 43",
-                        Number = 12
-                    },
-                    new Player
-                    {
-                        City = "Berlin",
-                        FirstName = "Alain",
-                        LastName = "Rochat",
-                        Street = "Wonderstreet 13",
-                        Number = 14
-                    }
-                },
-                Stadion = new Stadion
-                {
-                    Name = "Stade de Suisse",
-                    City = "Bern",
-                    Street = "Papiermühlestrasse 71"
-                }
-            });
+            // Here you can seed your core data if you have any.
         }
     }
 }

SQLite.CodeFirst.Console/Program.cs

@@ -1,34 +1,107 @@
-using SQLite.CodeFirst.Console.Entity;
+using System.Collections.Generic;
+using System.Data.Entity;
+using System.Data.SQLite;
+using System.Linq;
+using SQLite.CodeFirst.Console.Entity;
 
 namespace SQLite.CodeFirst.Console
 {
     public static class Program
     {
-        static void Main()
+        private static void Main()
         {
-            System.Console.WriteLine("Starting Demo Application");
+            StartDemoUseInMemory();
+            StartDemoUseFile();
+            PressEnterToExit();
+        }
 
-            var context = CreateAndSeedDatabase();
+        private static void StartDemoUseInMemory()
+        {
+            System.Console.WriteLine("Starting Demo Application (In Memory)");
+            System.Console.WriteLine(string.Empty);
 
-            DisplaySeededData(context);
+            using (var sqLiteConnection = new SQLiteConnection("data source=:memory:"))
+            {
+                // This is required if a in memory db is used.
+                sqLiteConnection.Open();
 
-            PressEnterToExit();
+                using (var context = new FootballDbContext(sqLiteConnection, false))
+                {
+                    CreateAndSeedDatabase(context);
+                    DisplaySeededData(context);
+                }
+            }
         }
 
-        private static FootballDbContext CreateAndSeedDatabase()
+        private static void StartDemoUseFile()
+        {
+            System.Console.WriteLine("Starting Demo Application (File)");
+            System.Console.WriteLine(string.Empty);
+
+            using (var context = new FootballDbContext("footballDb"))
+            {
+                CreateAndSeedDatabase(context);
+                DisplaySeededData(context);
+            }
+        }
+
+        private static void CreateAndSeedDatabase(DbContext context)
         {
             System.Console.WriteLine("Create and seed the database.");
-            var context = new FootballDbContext();
+
+            if (context.Set<Team>().Count() != 0)
+            {
+                return;
+            }
+
+            context.Set<Team>().Add(new Team
+            {
+                Name = "YB",
+                Coach = new Coach
+                {
+                    City = "Zürich",
+                    FirstName = "Masssaman",
+                    LastName = "Nachn",
+                    Street = "Testingstreet 844"
+                },
+                Players = new List<Player>
+                {
+                    new Player
+                    {
+                        City = "Bern",
+                        FirstName = "Marco",
+                        LastName = "Bürki",
+                        Street = "Wunderstrasse 43",
+                        Number = 12
+                    },
+                    new Player
+                    {
+                        City = "Berlin",
+                        FirstName = "Alain",
+                        LastName = "Rochat",
+                        Street = "Wonderstreet 13",
+                        Number = 14
+                    }
+                },
+                Stadion = new Stadion
+                {
+                    Name = "Stade de Suisse",
+                    City = "Bern",
+                    Street = "Papiermühlestrasse 71"
+                }
+            });
+
+            context.SaveChanges();
+
             System.Console.WriteLine("Completed.");
             System.Console.WriteLine();
-            return context;
         }
 
-        private static void DisplaySeededData(FootballDbContext context)
+        private static void DisplaySeededData(DbContext context)
         {
             System.Console.WriteLine("Display seeded data.");
 
-            foreach (var team in context.Set<Team>())
+            foreach (Team team in context.Set<Team>())
             {
                 System.Console.WriteLine("\t Team:");
                 System.Console.WriteLine("\t Id: {0}", team.Id);
@@ -49,7 +122,7 @@ private static void DisplaySeededData(FootballDbContext context)
                 System.Console.WriteLine("\t\t City: {0}", team.Coach.City);
                 System.Console.WriteLine();
 
-                foreach (var player in team.Players)
+                foreach (Player player in team.Players)
                 {
                     System.Console.WriteLine("\t\t Player:");
                     System.Console.WriteLine("\t\t Id: {0}", player.Id);
@@ -70,4 +143,4 @@ private static void PressEnterToExit()
             System.Console.ReadLine();
         }
     }
-}
+}

SQLite.CodeFirst.Test/IntegrationTests/MemoryDbTest.cs

@@ -0,0 +1,71 @@
+using System.Collections.Generic;
+using System.Data.Common;
+using System.Data.SQLite;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using SQLite.CodeFirst.Console;
+using SQLite.CodeFirst.Console.Entity;
+
+namespace SQLite.CodeFirst.Test.IntegrationTests
+{
+    [TestClass]
+    public class MemoryDbTest
+    {
+        [TestMethod]
+        public void CreateInMemoryDatabaseTest()
+        {
+            using (DbConnection connection = new SQLiteConnection("data source=:memory:"))
+            {
+                // This is important! Else the in memory database will not work.
+                connection.Open();
+
+                using (var context = new FootballDbContext(connection, false))
+                {
+                    context.Set<Team>().Add(new Team
+                    {
+                        Name = "New",
+                        Coach = new Coach
+                        {
+                            City = "New",
+                            FirstName = "New",
+                            LastName = "New",
+                            Street = "New"
+                        },
+                        Players = new List<Player>
+                        {
+                            new Player
+                            {
+                                City = "New",
+                                FirstName = "New",
+                                LastName = "New",
+                                Street = "New",
+                                Number = 1
+                            },
+                            new Player
+                            {
+                                City = "New",
+                                FirstName = "New",
+                                LastName = "New",
+                                Street = "New",
+                                Number = 2
+                            }
+                        },
+                        Stadion = new Stadion
+                        {
+                            Name = "New",
+                            City = "New",
+                            Street = "New"
+                        }
+                    });
+
+                    context.SaveChanges();
+                }
+
+                using (var context = new FootballDbContext(connection, false))
+                {
+                    Assert.AreEqual(1, context.Set<Team>().Count());
+                }
+            }
+        }
+    }
+}

SQLite.CodeFirst.Test/IntegrationTests/SqlGenerationTest.cs

@@ -0,0 +1,94 @@
+using System;
+using System.Data.Common;
+using System.Data.Entity;
+using System.Data.Entity.Infrastructure;
+using System.Data.SQLite;
+using System.Linq;
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+using SQLite.CodeFirst.Console;
+using SQLite.CodeFirst.Console.Entity;
+
+namespace SQLite.CodeFirst.Test.IntegrationTests
+{
+    [TestClass]
+    public class SqlGenerationTest
+    {
+        private const string ReferenceSql =
+            @"CREATE TABLE ""MyTable"" ([Id] int NOT NULL, [Name] nvarchar NOT NULL, PRIMARY KEY(Id), FOREIGN KEY (Id) REFERENCES ""Coaches""(Id));
+CREATE TABLE ""Coaches"" ([Id] INTEGER, [FirstName] nvarchar (50) COLLATE NOCASE, [LastName] nvarchar (50), [Street] nvarchar (100), [City] nvarchar NOT NULL, PRIMARY KEY(Id));
+CREATE TABLE ""TeamPlayer"" ([Id] INTEGER, [Number] int NOT NULL, [TeamId] int NOT NULL, [FirstName] nvarchar (50) COLLATE NOCASE, [LastName] nvarchar (50), [Street] nvarchar (100), [City] nvarchar NOT NULL, [Mentor_Id] int, PRIMARY KEY(Id), FOREIGN KEY (Mentor_Id) REFERENCES ""TeamPlayer""(Id), FOREIGN KEY (TeamId) REFERENCES ""MyTable""(Id) ON DELETE CASCADE);
+CREATE TABLE ""Stadions"" ([Name] nvarchar (128) NOT NULL, [Street] nvarchar (128) NOT NULL, [City] nvarchar (128) NOT NULL, [Team_Id] int NOT NULL, PRIMARY KEY(Name, Street, City), FOREIGN KEY (Team_Id) REFERENCES ""MyTable""(Id) ON DELETE CASCADE);
+CREATE TABLE ""Foos"" ([FooId] INTEGER, [Name] nvarchar, [FooSelf1Id] int, [FooSelf2Id] int, [FooSelf3Id] int, PRIMARY KEY(FooId), FOREIGN KEY (FooSelf1Id) REFERENCES ""Foos""(FooId), FOREIGN KEY (FooSelf2Id) REFERENCES ""Foos""(FooId), FOREIGN KEY (FooSelf3Id) REFERENCES ""Foos""(FooId));
+CREATE TABLE ""FooSelves"" ([FooSelfId] INTEGER, [FooId] int NOT NULL, [Number] int NOT NULL, PRIMARY KEY(FooSelfId), FOREIGN KEY (FooId) REFERENCES ""Foos""(FooId) ON DELETE CASCADE);
+CREATE TABLE ""FooSteps"" ([FooStepId] INTEGER, [FooId] int NOT NULL, [Number] int NOT NULL, PRIMARY KEY(FooStepId), FOREIGN KEY (FooId) REFERENCES ""Foos""(FooId) ON DELETE CASCADE);
+CREATE  INDEX ""IX_MyTable_Id"" ON ""MyTable"" (Id);
+CREATE  INDEX IX_Team_TeamsName ON ""MyTable"" (Name);
+
+CREATE  INDEX ""IX_TeamPlayer_Number"" ON ""TeamPlayer"" (Number);
+CREATE UNIQUE INDEX IX_TeamPlayer_NumberPerTeam ON ""TeamPlayer"" (Number, TeamId);
+CREATE  INDEX ""IX_TeamPlayer_Mentor_Id"" ON ""TeamPlayer"" (Mentor_Id);
+CREATE UNIQUE INDEX IX_Stadion_Main ON ""Stadions"" (Street, Name);
+CREATE  INDEX ""IX_Stadion_Team_Id"" ON ""Stadions"" (Team_Id);
+CREATE  INDEX ""IX_Foo_FooSelf1Id"" ON ""Foos"" (FooSelf1Id);
+CREATE  INDEX ""IX_Foo_FooSelf2Id"" ON ""Foos"" (FooSelf2Id);
+CREATE  INDEX ""IX_Foo_FooSelf3Id"" ON ""Foos"" (FooSelf3Id);
+CREATE  INDEX ""IX_FooSelf_FooId"" ON ""FooSelves"" (FooId);
+CREATE  INDEX ""IX_FooStep_FooId"" ON ""FooSteps"" (FooId);";
+
+        private static string generatedSql;
+
+        // Does not work on the build server. No clue why.
+        [Ignore]
+        [TestMethod]
+        public void SqliteSqlGeneratorTest()
+        {
+            using (DbConnection connection = new SQLiteConnection("data source=:memory:"))
+            {
+                // This is important! Else the in memory database will not work.
+                connection.Open();
+
+                using (var context = new DummyDbContext(connection))
+                {
+                    // ReSharper disable once UnusedVariable
+                    Player fo = context.Set<Player>().FirstOrDefault();
+
+                    Assert.IsTrue(string.Equals(ReferenceSql.Trim(), generatedSql.Trim(), StringComparison.OrdinalIgnoreCase));
+                }
+            }
+        }
+
+        private class DummyDbContext : DbContext
+        {
+            public DummyDbContext(DbConnection connection)
+                : base(connection, false)
+            {
+            }
+
+            protected override void OnModelCreating(DbModelBuilder modelBuilder)
+            {
+                // This configuration contains all supported cases.
+                // So it makes a perfect test to validate whether the 
+                // generated SQL is correct.
+                ModelConfiguration.Configure(modelBuilder);
+                var initializer = new AssertInitializer(modelBuilder);
+                Database.SetInitializer(initializer);
+            }
+        }
+
+        private class AssertInitializer : SqliteInitializerBase<DummyDbContext>
+        {
+            public AssertInitializer(DbModelBuilder modelBuilder)
+                : base(modelBuilder)
+            {
+            }
+
+            public override void InitializeDatabase(DummyDbContext context)
+            {
+                DbModel model = ModelBuilder.Build(context.Database.Connection);
+                var sqliteSqlGenerator = new SqliteSqlGenerator();
+                generatedSql = sqliteSqlGenerator.Generate(model.StoreModel);
+                base.InitializeDatabase(context);
+            }
+        }
+    }
+}