protected virtual void AssertEqualFileContents(FileSet expected, FileSet actual)
{
Assert.Equal(expected.Files.Count, actual.Files.Count);
for (var i = 0; i < expected.Files.Count; i++)
{
Assert.True(actual.Exists(i), $"Could not find file '{actual.Files[i]}' in directory '{actual.Directory}'");
var expectedContents = expected.Contents(i);
var actualContents = actual.Contents(i);
try
{
Assert.Equal(expectedContents, actualContents);
}
catch (EqualException e)
{
var sep = new string('=', 60);
_output.WriteLine($"Contents of actual: '{actual.Files[i]}'");
_output.WriteLine(sep);
_output.WriteLine(actualContents);
_output.WriteLine(sep);
throw new XunitException($"Files did not match: '{expected.Files[i]}' and '{actual.Files[i]}'" + Environment.NewLine + $"{e.Message}");
}
}
}
public async void One_to_one()
{
using (var testStore = SqliteTestStore.GetOrCreateShared("OneToOne" + DbSuffix).AsTransient())
{
testStore.ExecuteNonQuery(@"
CREATE TABLE IF NOT EXISTS Principal (
Id INTEGER PRIMARY KEY AUTOINCREMENT
);
CREATE TABLE IF NOT EXISTS Dependent (
Id INT,
PrincipalId INT NOT NULL UNIQUE,
PRIMARY KEY (Id),
FOREIGN KEY (PrincipalId) REFERENCES Principal (Id)
);
");
testStore.Transaction.Commit();
var results = await Generator.GenerateAsync(new ReverseEngineeringConfiguration
{
ConnectionString = testStore.ConnectionString,
ProjectPath = TestProjectPath,
ProjectRootNamespace = "E2E.Sqlite",
UseFluentApiOnly = UseFluentApiOnly,
TableSelectionSet = TableSelectionSet.All
});
AssertLog(new LoggerMessages());
var expectedFileSet = new FileSet(new FileSystemFileService(), Path.Combine(ExpectedResultsParentDir, "OneToOne"))
{
Files =
{
"OneToOne" + DbSuffix + "Context.expected",
"Dependent.expected",
"Principal.expected"
}
};
var actualFileSet = new FileSet(InMemoryFiles, TestProjectFullPath)
{
Files = Enumerable.Repeat(results.ContextFile, 1).Concat(results.EntityTypeFiles).Select(Path.GetFileName).ToList()
};
AssertEqualFileContents(expectedFileSet, actualFileSet);
AssertCompile(actualFileSet);
}
}
protected virtual void AssertCompile(FileSet fileSet)
{
var fileContents = fileSet.Files.Select(fileSet.Contents).ToList();
var source = new BuildSource
{
Sources = fileContents
};
foreach (var r in References)
{
source.References.Add(r);
}
source.BuildInMemory();
}
public virtual async void Foreign_key_to_unique_index()
{
using (var testStore = SqliteTestStore.GetOrCreateShared("FkToAltKey" + DbSuffix).AsTransient())
{
testStore.ExecuteNonQuery(@"
CREATE TABLE IF NOT EXISTS User (
Id INTEGER PRIMARY KEY,
AltId INTEGER NOT NULL UNIQUE
);
CREATE TABLE IF NOT EXISTS Comment (
Id INTEGER PRIMARY KEY,
UserAltId INTEGER NOT NULL,
Contents TEXT,
FOREIGN KEY (UserAltId) REFERENCES User (AltId)
);");
testStore.Transaction.Commit();
var results = await Generator.GenerateAsync(new ReverseEngineeringConfiguration
{
ConnectionString = testStore.ConnectionString,
ContextClassName = "FkToAltKeyContext",
ProjectPath = TestProjectPath,
ProjectRootNamespace = "E2E.Sqlite",
UseFluentApiOnly = UseFluentApiOnly,
TableSelectionSet = TableSelectionSet.All
});
AssertLog(new LoggerMessages());
var expectedFileSet = new FileSet(new FileSystemFileService(), Path.Combine(ExpectedResultsParentDir, "FkToAltKey"))
{
Files =
{
"FkToAltKeyContext.expected",
"Comment.expected",
"User.expected"
}
};
var actualFileSet = new FileSet(InMemoryFiles, TestProjectFullPath)
{
Files = Enumerable.Repeat(results.ContextFile, 1).Concat(results.EntityTypeFiles).Select(Path.GetFileName).ToList()
};
AssertEqualFileContents(expectedFileSet, actualFileSet);
AssertCompile(actualFileSet);
}
}
public async void It_handles_unsafe_names()
{
using (var testStore = SqliteTestStore.CreateScratch())
{
testStore.ExecuteNonQuery(@"
CREATE TABLE IF NOT EXISTS 'Named with space' ( Id PRIMARY KEY );
CREATE TABLE IF NOT EXISTS '123 Invalid Class Name' ( Id PRIMARY KEY);
CREATE TABLE IF NOT EXISTS 'Bad characters `~!@#$%^&*()+=-[];''"",.<>/?|\ ' ( Id PRIMARY KEY);
CREATE TABLE IF NOT EXISTS ' Bad columns ' (
'Space jam' PRIMARY KEY,
'123 Go`',
'Bad to the bone. `~!@#$%^&*()+=-[];''"",.<>/?|\ ',
'Next one is all bad',
'@#$%^&*()'
);
CREATE TABLE IF NOT EXISTS Keywords (
namespace PRIMARY KEY,
virtual,
public,
class,
string,
FOREIGN KEY (class) REFERENCES string (string)
);
CREATE TABLE IF NOT EXISTS String (
string PRIMARY KEY,
FOREIGN KEY (string) REFERENCES String (string)
);
");
var results = await Generator.GenerateAsync(new ReverseEngineeringConfiguration
{
ConnectionString = testStore.ConnectionString,
ProjectPath = TestProjectPath,
ProjectRootNamespace = "E2E.Sqlite",
UseFluentApiOnly = UseFluentApiOnly,
TableSelectionSet = TableSelectionSet.All
});
AssertLog(new LoggerMessages());
var files = new FileSet(InMemoryFiles, TestProjectFullPath)
{
Files = Enumerable.Repeat(results.ContextFile, 1).Concat(results.EntityTypeFiles).Select(Path.GetFileName).ToList()
};
AssertCompile(files);
}
}
public async void Principal_missing_primary_key()
{
using (var testStore = SqliteTestStore.GetOrCreateShared("NoPrincipalPk" + DbSuffix).AsTransient())
{
testStore.ExecuteNonQuery(@"CREATE TABLE IF NOT EXISTS Dependent (
Id PRIMARY KEY,
PrincipalId INT,
FOREIGN KEY (PrincipalId) REFERENCES Principal(Id)
);
CREATE TABLE IF NOT EXISTS Principal ( Id INT);");
testStore.Transaction.Commit();
var results = await Generator.GenerateAsync(new ReverseEngineeringConfiguration
{
ConnectionString = testStore.ConnectionString,
ProjectPath = TestProjectPath,
ProjectRootNamespace = "E2E.Sqlite",
UseFluentApiOnly = UseFluentApiOnly,
TableSelectionSet = TableSelectionSet.All
});
var expectedLog = new LoggerMessages
{
Warn =
{
RelationalDesignStrings.MissingPrimaryKey("Principal"),
RelationalDesignStrings.UnableToGenerateEntityType("Principal"),
RelationalDesignStrings.ForeignKeyScaffoldErrorPrincipalTableScaffoldingError("Dependent(PrincipalId)", "Principal")
}
};
AssertLog(expectedLog);
var expectedFileSet = new FileSet(new FileSystemFileService(), Path.Combine(ExpectedResultsParentDir, "NoPrincipalPk"))
{
Files =
{
"NoPrincipalPk" + DbSuffix + "Context.expected",
"Dependent.expected"
}
};
var actualFileSet = new FileSet(InMemoryFiles, TestProjectFullPath)
{
Files = Enumerable.Repeat(results.ContextFile, 1).Concat(results.EntityTypeFiles).Select(Path.GetFileName).ToList()
};
AssertEqualFileContents(expectedFileSet, actualFileSet);
AssertCompile(actualFileSet);
}
}
public async void Many_to_many()
{
using (var testStore = SqliteTestStore.GetOrCreateShared("ManyToMany" + DbSuffix).AsTransient())
{
testStore.ExecuteNonQuery(@"
CREATE TABLE IF NOT EXISTS Users ( Id PRIMARY KEY);
CREATE TABLE IF NOT EXISTS Groups (Id PRIMARY KEY);
CREATE TABLE IF NOT EXISTS Users_Groups (
Id PRIMARY KEY,
UserId,
GroupId,
UNIQUE (UserId, GroupId),
FOREIGN KEY (UserId) REFERENCES Users (Id),
FOREIGN KEY (GroupId) REFERENCES Groups (Id)
);
");
testStore.Transaction.Commit();
var results = await Generator.GenerateAsync(new ReverseEngineeringConfiguration
{
ConnectionString = testStore.ConnectionString,
ProjectPath = TestProjectPath,
ProjectRootNamespace = "E2E.Sqlite",
UseFluentApiOnly = UseFluentApiOnly,
TableSelectionSet = TableSelectionSet.All
});
AssertLog(new LoggerMessages());
var expectedFileSet = new FileSet(new FileSystemFileService(), Path.Combine(ExpectedResultsParentDir, "ManyToMany"))
{
Files =
{
"ManyToMany" + DbSuffix + "Context.expected",
"Groups.expected",
"Users.expected",
"UsersGroups.expected"
}
};
var actualFileSet = new FileSet(InMemoryFiles, TestProjectFullPath)
{
Files = Enumerable.Repeat(results.ContextFile, 1).Concat(results.EntityTypeFiles).Select(Path.GetFileName).ToList()
};
AssertEqualFileContents(expectedFileSet, actualFileSet);
AssertCompile(actualFileSet);
}
}
