public void TestSaveAndRemoveSettings()
{
var repository = new SqlRewriteDbRepository(new SqlConnection(Settings.Default.ConnectionString));
var settings = new SqlRewriteSettings
{
Id = 0, // This will cause insertion
ProcessNameRegEx = ".*",
MachineRegEx = ".*",
StackFrameIgnorePrefixes = "[mscorlib].\r\nSqlInterceptorsTests."
};
repository.SaveSqlRewriteSettings(settings);
try
{
Assert.AreNotEqual(0, settings.Id);
var items = repository.LoadSqlRewriteSettings();
SettingsExists(items, settings);
repository.RemoveSqlRewriteSettings(settings.Id);
items = repository.LoadSqlRewriteSettings();
Assert.ThrowsException <Exception>(() => { SettingsExists(items, settings); });
}
finally
{
try
{
repository.RemoveSqlRewriteSettings(settings.Id);
}
catch (Exception)
{
// Ignore exception
}
}
}
public IEnumerable <SqlRewriteSettings> LoadSqlRewriteSettings()
{
var result = new List <SqlRewriteSettings>();
using var loadSqlRewriteSettings = new SqlCommand(@"
SELECT ID, MachineRegEx, ProcessNameRegEx, Enabled, HashInjectionEnabled, RegExInjectionEnabled, StackFrameInjectionEnabled, CallStackEntriesToReport, StackFrameIgnorePrefixes
FROM SqlRewriteInjectorSettings", _sqlConnection);
using var resultSet = loadSqlRewriteSettings.ExecuteReader();
while (resultSet.Read())
{
var item = new SqlRewriteSettings
{
Id = (int)resultSet[0],
MachineRegEx = (string)resultSet[1],
ProcessNameRegEx = (string)resultSet[2],
Enabled = (bool)resultSet[3],
HashInjectionEnabled = (bool)resultSet[4],
RegExInjectionEnabled = (bool)resultSet[5],
StackFrameInjectionEnabled = (bool)resultSet[6],
CallStackEntriesToReport = (int)resultSet[7],
StackFrameIgnorePrefixes = (string)resultSet[8]
};
result.Add(item);
}
return(result);
}
public void TestApplySettings()
{
using var conn = new SqlConnection(Settings.Default.ConnectionString);
var repo = new SqlRewriteDbRepository(conn);
repo.RemoveAllSqlRewriteSettings();
var settings = new SqlRewriteSettings()
{
MachineRegEx = Settings.Default.MachineNameMatchString,
ProcessNameRegEx = "Program Files",
Enabled = true,
HashInjectionEnabled = false,
RegExInjectionEnabled = false,
StackFrameInjectionEnabled = false,
StackFrameIgnorePrefixes = "Microsoft.VisualStudio.TestTools.UnitTesting"
};
repo.SaveSqlRewriteSettings(settings);
using var service = new SqlRewriteRuleService(repo);
Assert.IsFalse(service.Enabled);
Assert.IsTrue(SqlCommandRegExProcessor.RegExInjectionEnabled);
Assert.IsTrue(SqlCommandTextStackTraceInjector.HashInjectionEnabled);
Assert.IsTrue(SqlCommandTextStackTraceInjector.StackInjectionEnabled);
Assert.AreEqual("", SqlCommandTextStackTraceInjector.StackFrameIgnorePrefixes);
service.Enabled = true;
service.ApplySettingsFromRepository();
Assert.IsTrue(service.Enabled);
Assert.IsFalse(SqlCommandRegExProcessor.RegExInjectionEnabled);
Assert.IsFalse(SqlCommandTextStackTraceInjector.HashInjectionEnabled);
Assert.IsFalse(SqlCommandTextStackTraceInjector.StackInjectionEnabled);
Assert.AreEqual("Microsoft.VisualStudio.TestTools.UnitTesting", SqlCommandTextStackTraceInjector.StackFrameIgnorePrefixes);
repo.RemoveSqlRewriteSettings(settings.Id);
settings.Enabled = false;
settings.HashInjectionEnabled = true;
settings.RegExInjectionEnabled = true;
settings.StackFrameInjectionEnabled = true;
settings.StackFrameIgnorePrefixes = "";
repo.SaveSqlRewriteSettings(settings);
service.ApplySettingsFromRepository();
Assert.IsFalse(service.Enabled);
Assert.IsTrue(SqlCommandRegExProcessor.RegExInjectionEnabled);
Assert.IsTrue(SqlCommandTextStackTraceInjector.HashInjectionEnabled);
Assert.IsTrue(SqlCommandTextStackTraceInjector.StackInjectionEnabled);
Assert.AreEqual("", SqlCommandTextStackTraceInjector.StackFrameIgnorePrefixes);
service.RemoveSettings(settings.Id);
var id = service.StoreCurrentSettings(settings.MachineRegEx, settings.ProcessNameRegEx);
Assert.AreNotEqual(settings.Id, id);
service.ApplySettingsFromRepository();
Assert.IsFalse(service.Enabled);
Assert.IsTrue(SqlCommandRegExProcessor.RegExInjectionEnabled);
Assert.IsTrue(SqlCommandTextStackTraceInjector.HashInjectionEnabled);
Assert.IsTrue(SqlCommandTextStackTraceInjector.StackInjectionEnabled);
Assert.AreEqual("", SqlCommandTextStackTraceInjector.StackFrameIgnorePrefixes);
service.RemoveSettings(id);
// ReSharper disable once AccessToDisposedClosure
Assert.ThrowsException <SqlRewriteRuleDbRepositoryException>(() => { service.RemoveSettings(id); });
}
public void SaveSqlRewriteSettings(SqlRewriteSettings settings)
{
using var saveSqlRewriteSettings = new SqlCommand(@"
MERGE SqlRewriteInjectorSettings AS t
USING (
SELECT @ID, @MachineRegEx, @ProcessNameRegEx, @Enabled, @HashInjectionEnabled, @RegExInjectionEnabled, @StackFrameInjectionEnabled, @CallStackEntriesToReport, @StackFrameIgnorePrefixes
) AS src (ID, MachineRegEx, ProcessNameRegEx, Enabled, HashInjectionEnabled, RegExInjectionEnabled, StackFrameInjectionEnabled, CallStackEntriesToReport, StackFrameIgnorePrefixes)
ON (t.ID = src.ID)
WHEN MATCHED THEN
UPDATE SET
t.MachineRegEx = src.MachineRegEx,
t.ProcessNameRegEx = src.ProcessNameRegEx,
t.Enabled = src.Enabled,
t.HashInjectionEnabled = src.HashInjectionEnabled,
t.RegExInjectionEnabled = src.RegExInjectionEnabled,
t.StackFrameInjectionEnabled = src.StackFrameInjectionEnabled,
t.CallStackEntriesToReport = src.CallStackEntriesToReport,
t.StackFrameIgnorePrefixes = src.StackFrameIgnorePrefixes
WHEN NOT MATCHED THEN
INSERT (MachineRegEx,
ProcessNameRegEx,
Enabled,
HashInjectionEnabled,
RegExInjectionEnabled,
StackFrameInjectionEnabled,
CallStackEntriesToReport,
StackFrameIgnorePrefixes)
VALUES (src.MachineRegEx,
src.ProcessNameRegEx,
src.Enabled,
src.HashInjectionEnabled,
src.RegExInjectionEnabled,
src.StackFrameInjectionEnabled,
src.CallStackEntriesToReport,
src.StackFrameIgnorePrefixes)
OUTPUT Inserted.ID;", _sqlConnection);
saveSqlRewriteSettings.Parameters.AddRange(new[]
{
new SqlParameter("@ID", settings.Id),
new SqlParameter("@MachineRegEx", settings.MachineRegEx),
new SqlParameter("@ProcessNameRegEx", settings.ProcessNameRegEx),
new SqlParameter("@Enabled", settings.Enabled ? 1 : 0),
new SqlParameter("@HashInjectionEnabled", settings.HashInjectionEnabled ? 1 : 0),
new SqlParameter("@StackFrameInjectionEnabled", settings.StackFrameInjectionEnabled ? 1 : 0),
new SqlParameter("@RegExInjectionEnabled", settings.RegExInjectionEnabled ? 1 : 0),
new SqlParameter("@CallStackEntriesToReport", settings.CallStackEntriesToReport),
new SqlParameter("@StackFrameIgnorePrefixes", settings.StackFrameIgnorePrefixes),
});
var result = saveSqlRewriteSettings.ExecuteScalar();
if (result is DBNull)
{
throw new SqlRewriteRuleDbRepositoryException("Call to saveSqlRewriteSettings.ExecuteScalar() should always return a non-null value");
}
settings.Id = (int)result;
}
public void TestSettingsMatch()
{
var settingsObj = new SqlRewriteSettings
{
MachineRegEx = Settings.Default.MachineNameMatchString,
ProcessNameRegEx = "program Files", // We will ignore case for machine name and process matching
StackFrameIgnorePrefixes = "Base.Second.Third\r\nAnother.One\rThird.One\nFourth.One"
};
Assert.IsTrue(settingsObj.MatchMachineName());
Assert.IsTrue(settingsObj.MatchProcessName());
}
private static void SettingsExists(IEnumerable <SqlRewriteSettings> items, SqlRewriteSettings item)
{
foreach (var loadedItem in items)
{
if (loadedItem.Id != item.Id)
{
continue;
}
Assert.AreEqual(item.Id, loadedItem.Id);
Assert.AreEqual(item.ProcessNameRegEx, loadedItem.ProcessNameRegEx);
Assert.AreEqual(item.MachineRegEx, loadedItem.MachineRegEx);
Assert.AreEqual(item.Enabled, loadedItem.Enabled);
Assert.AreEqual(item.HashInjectionEnabled, loadedItem.HashInjectionEnabled);
Assert.AreEqual(item.RegExInjectionEnabled, loadedItem.RegExInjectionEnabled);
Assert.AreEqual(item.StackFrameInjectionEnabled, loadedItem.StackFrameInjectionEnabled);
Assert.AreEqual(item.CallStackEntriesToReport, loadedItem.CallStackEntriesToReport);
Assert.AreEqual(item.StackFrameIgnorePrefixes, loadedItem.StackFrameIgnorePrefixes);
return;
}
throw new Exception("Settings entry doesn't exist");
}
