public override Dataset ReadTableData(string command, FormatterManager formatter) { using var connection = CreateDbConnection(ConnectionString); connection.Open(); using var sqlCommand = CreateDbCommand(command, connection); using var reader = sqlCommand.ExecuteReader(CommandBehavior.KeyInfo); var tableName = reader.GetSchemaTable().Rows[0]["BaseTableName"].ToString(); var dataset = new Dataset(); var rows = new List <Row>(); while (reader.Read()) { var columns = new List <Column>(); for (var i = 0; i < reader.VisibleFieldCount; i++) { var column = new Column(reader.GetName(i), formatter.Format(tableName ?? "", reader.GetName(i), reader[i])); columns.Add(column); } var row = new Row { Columns = columns }; rows.Add(row); } dataset.Rows = rows; return(dataset); }
public override DatasetElement ReadTable(string command, FormatterManager formatter) { DatasetElement result = new DatasetElement(); result.Data = new XElement("data"); using (var conn = CreateDbConnection(ConnectionString)) { conn.Open(); using (var comm = CreateDbCommand(command, conn)) { var reader = comm.ExecuteReader(CommandBehavior.KeyInfo); var tableSchema = reader.GetSchemaTable(); result.Table = tableSchema.TableName; while (reader.Read()) { XElement xmlRow = new XElement("row"); result.Data.Add(xmlRow); for (int i = 0; i < reader.FieldCount; i++) { var columnName = reader.GetName(i); var value = formatter.Format(tableSchema.TableName, columnName, reader[i]); var attribute = new XAttribute(columnName, value); xmlRow.Add(attribute); } } } } return(result); }
public void Connection_is_not_reused() { // This test uses a global temp table (GTT) since a GTT is deleted when the connection that created it goes out of scope. var target = new SqlDatabaseClient(false) { ConnectionString = _connectionString }; target.ExecuteCommand(_createGlobalTempTableCommand); var formatterManager = new FormatterManager(); var actual = target.ReadTable(_verifyIfTempTableExistsQuery, formatterManager); var expectedDatasetXml = @" <dataset name=""a-name"" table=""a-name""> <data> <row TempTableExists=""0"" /> </data> </dataset> "; var xml = XElement.Parse(expectedDatasetXml); var expectedDataset = DatasetElement.Load(xml); Assert.AreEqual(expectedDataset.Data.ToString(), actual.Data.ToString()); }
public void WriteReport(Server server, FormatterManager formatterManager) { formatterManager.InitializeSection(".NET"); foreach (var site in server.Sites) { foreach (var directory in site.VirtualDirectories) { formatterManager.InitializeRecord(); formatterManager.WriteValue("Site Name", site.Name); formatterManager.WriteValue("Path", directory.Path); formatterManager.WriteValue("Site Name", site.Name); formatterManager.WriteValue("Path", directory.Path); formatterManager.WriteValue("Physical Path", directory.PhysicalPath); formatterManager.WriteValue("Authentication Mode", directory.AuthenticationMode); formatterManager.WriteValue("Target .NET Framework", directory.TargetDotNetFramework); formatterManager.WriteValue("Debug Enabled", directory.DebugEnabled.ToString()); formatterManager.WriteValue("Reveals Stock Error Pages", directory.RevealsStockErrorPages.ToString()); formatterManager.WriteValue("Reveals Error Urls", directory.RevealsErrorUrls.ToString()); formatterManager.WriteValue("Reveals ASP.NET Version Header", directory.RevealsAspNetVersionHeader.ToString()); formatterManager.WriteValue("Request Validation Disabled", directory.RequestValidationDisabled.ToString()); formatterManager.WriteValue("JavaScript Can Access Cookies", directory.JavaScriptCanAccessCookies.ToString()); formatterManager.WriteValue("Insecure Cookies Allowed", directory.InsecureCookiesAllowed.ToString()); formatterManager.WriteValue("Cookieless Sessions Allowed", directory.CookielessSessionsAllowed.ToString()); formatterManager.WriteValue("Trace Publicly Enabled", directory.TracePubliclyEnabled.ToString()); } } }
private static IServiceCollection AddFormatterManager(this IServiceCollection services) { IFormatterManager formatterManager = new FormatterManager(); formatterManager.RegisterFormatter("json", new JsonReportFormatter()); formatterManager.RegisterFormatter("xml", new XmlReportFormatter()); return(services.AddSingleton(formatterManager)); }
public void Format_WhenNoFormattersAreRegistered_ReturnValueAsString() { formatterManager = new FormatterManager(); var actual = formatterManager.Format("TableB", "ColumnA", 5); actual.Should().Be("5", "because there aren't any formatters registered"); }
public void Format_When_there_are_zero_registered_formatters_Format_must_return_value_to_string() { _target = new FormatterManager(); var actual = _target.Format("TableB", "ColumnA", 5); Assert.AreEqual("5", actual); }
public IFormatter Create(Type type) { Type underlyingType = type.GetEnumUnderlyingType(); IFormatter underlyingFormatter = FormatterManager.GetFormatterAsync(underlyingType, false).Result; Context context = new Context(type, underlyingFormatter, underlyingType); return(context.BuildFormatter()); }
public void WriteReport(Server server, FormatterManager formatterManager) { formatterManager.InitializeSection("Summary"); formatterManager.InitializeRecord(); formatterManager.WriteValue("Server Name", server.Name); formatterManager.WriteValue("# of App Pools", server.AppPools.Count.ToString()); formatterManager.WriteValue("# of Sites", server.Sites.Count.ToString()); formatterManager.WriteValue("# of Bindings with HTTPS", server.Sites.Select(site => site.Bindings.Count(binding => binding.Protocol.ToLower() == "https")).Sum().ToString()); }
public FormatterManagerTest() { formatterManager = new FormatterManager(); formatterManager.Register(typeof(DateTime), value => "registered-for-date-time"); formatterManager.Register("TableA", "ColumnA", value => "registered-for-TableA-ColumnA"); formatterManager.Register("TableA", "ColumnB", value => "registered-for-TableA-ColumnB"); formatterManager.Register("TableB", "ColumnA", value => "registered-for-TableB-ColumnA"); formatterManager.Register("ColumnA", value => "registered-for-ColumnA"); }
public void Initialize() { _target = new FormatterManager(); _target.Register(typeof(DateTime), value => "registered-for-date-time"); _target.Register("TableA", "ColumnA", value => "registered-for-TableA-ColumnA"); _target.Register("TableA", "ColumnB", value => "registered-for-TableA-ColumnB"); _target.Register("TableB", "ColumnA", value => "registered-for-TableB-ColumnA"); _target.Register("ColumnA", value => "registered-for-ColumnA"); }
public void GetFormatterTest(IDictionary <string, IReportFormatter> formatterStorage, string formatterName, IReportFormatter expected) { // Arrange var manager = new FormatterManager(formatterStorage); // Act IReportFormatter formatter = manager.GetFormatter(formatterName); // Assert Assert.That(formatter, Is.EqualTo(expected)); }
public void GetFormatterTest_ThrowsException(string formatterName) { // Arrange var manager = new FormatterManager(); // Act IReportFormatter TestAction() => manager.GetFormatter(formatterName); // Assert Assert.That(TestAction, Throws.TypeOf <FormatterNotFoundException>()); }
public AowSerializer(bool hasRootWrapper, bool forceClassID) { _isAbstract = typeof(T).IsAbstract || forceClassID; _hasRootWrapper = hasRootWrapper; _formatter = FormatterManager.GetFormatter <T>(isPolymorph: _isAbstract); if (_hasRootWrapper) { _formatter = new WrappingFormatterProxy(_formatter); } }
public void RegisterFormatterTest_ThrowsException(IDictionary <string, IReportFormatter> storage, string name, IReportFormatter formatter, Type expectedException) { // Arrange var manager = new FormatterManager(storage); // Act void TestAction() => manager.RegisterFormatter(name, formatter); // Assert Assert.That(TestAction, Throws.TypeOf(expectedException)); }
public void WriteReport(Server server, FormatterManager formatterManager) { formatterManager.InitializeSection("Application Pools"); foreach (var appPool in server.AppPools) { formatterManager.InitializeRecord(); formatterManager.WriteValue("Name", appPool.Name); formatterManager.WriteValue("Current State", appPool.CurrentState); formatterManager.WriteValue("Runtime Version", appPool.RuntimeVersion); formatterManager.WriteValue("Pipeline Mode", appPool.PipelineMode); formatterManager.WriteValue("Auto Start", appPool.AutoStart.ToString()); formatterManager.WriteValue("Username", appPool.UserName); formatterManager.WriteValue("Identity Type", appPool.IdentityType); } }
private void CreateItemFormatter() { Task <IFormatter> itemFormatter = FormatterManager.GetFormatterAsync(ItemType, isPolymorph: true); Type formatterType = typeof(Task <IFormatter>); string fieldName = "ItemFormatter"; TypeBuilder helperBuilder = GeneratedAssembly.CreateType(Type.Name + "FormatterHelper"); FieldBuilder cachedFormatterField = helperBuilder.DefineField(fieldName, formatterType, FieldAttributes.Static | FieldAttributes.Public); Type helperType = helperBuilder.CreateType(); FieldInfo realFieldInfo = helperType.GetField(fieldName); realFieldInfo.SetValue(null, itemFormatter); _itemFormatterField = realFieldInfo; _itemFormatterType = typeof(Formatter <>).MakeGenericType(ItemType); }
public void WriteReport(Server server, FormatterManager formatterManager) { formatterManager.InitializeSection("Databases"); foreach (var site in server.Sites) { foreach (var directory in site.VirtualDirectories) { foreach (var database in directory.Databases) { formatterManager.InitializeRecord(); formatterManager.WriteValue("Site Name", site.Name); formatterManager.WriteValue("Path", directory.Path); formatterManager.WriteValue("Connection Name", database.ConnectionName); formatterManager.WriteValue("Provider", database.Provider); formatterManager.WriteValue("Connection String", database.ConnectionString); } } } }
public void WriteReport(Server server, FormatterManager formatterManager) { formatterManager.InitializeSection("Sites"); foreach (var site in server.Sites) { formatterManager.InitializeRecord(); formatterManager.WriteValue("Name", site.Name); formatterManager.WriteValue("Current State", site.CurrentState); formatterManager.WriteValue("Auto Start", site.AutoStart.ToString()); formatterManager.WriteValue("# of Bindings", site.Bindings.Count.ToString()); formatterManager.WriteValue("# of Virtual Directories", site.VirtualDirectories.Count.ToString()); } formatterManager.InitializeSection("Bindings"); foreach (var site in server.Sites) { foreach (var binding in site.Bindings) { formatterManager.InitializeRecord(); formatterManager.WriteValue("Site Name", site.Name); formatterManager.WriteValue("Protocol", binding.Protocol); formatterManager.WriteValue("IP Address", binding.IpAddress); formatterManager.WriteValue("Port", binding.Port); formatterManager.WriteValue("Host Name", binding.HostName); formatterManager.WriteValue("Certificate Name", binding.CertificateName); } } formatterManager.InitializeSection("Virtual Directories"); foreach (var site in server.Sites) { foreach (var directory in site.VirtualDirectories) { formatterManager.InitializeRecord(); formatterManager.WriteValue("Site Name", site.Name); formatterManager.WriteValue("Path", directory.Path); formatterManager.WriteValue("Physical Path", directory.PhysicalPath); formatterManager.WriteValue("Application Pool", directory.AppPool); formatterManager.WriteValue("Application Path", directory.AppPath); } } }
public void WriteReport(Server server, FormatterManager formatterManager) { formatterManager.InitializeSection("JavaScript"); foreach (var site in server.Sites) { foreach (var directory in site.VirtualDirectories) { formatterManager.InitializeRecord(); formatterManager.WriteValue("Site Name", site.Name); formatterManager.WriteValue("Path", directory.Path); formatterManager.WriteValue("May Use Angular.js 1.x", directory.FoundAngular1.ToString()); formatterManager.WriteValue("May Use React.js", directory.FoundReact.ToString()); formatterManager.WriteValue("May Use Backbone.js", directory.FoundBackbone.ToString()); formatterManager.WriteValue("May Use Ember.js", directory.FoundEmber.ToString()); formatterManager.WriteValue("May Use Knockout.js", directory.FoundKnockout.ToString()); formatterManager.WriteValue("May Use jQuery", directory.FoundjQuery.ToString()); formatterManager.WriteValue("May Use Underscore/Lodash", directory.FoundUnderscoreOrLodash.ToString()); formatterManager.WriteValue("May Use Bootstrap CSS", directory.FoundBootstrap.ToString()); } } }
/// <summary> /// /// </summary> public AppHost(RpcConfig config) { if (config == null) { throw new ArgumentNullException(nameof(config)); } Config = config; AppId = config.AppId; Registry = RegistryHelper.GetRegistry(this, config); ServiceHost = new ServiceHost(this, config); FormatterManager = new FormatterManager(config); ClientFactory = new RpcClientFactory(this, config); if (!string.IsNullOrWhiteSpace(config.Monitor?.Type)) { var monitorFactory = ReflectHelper.CreateInstanceByIdentifier <IMonitorFactory>(config.Monitor.Type); Monitor = monitorFactory.CreateMonitor(this, config); } if (config.Filter?.Filters.Count > 0) { foreach (var item in config.Filter.Filters) { var factory = ReflectHelper.CreateInstanceByIdentifier <IFilterFactory>(item.Type); var filters = factory.CreateFilters(); if (filters == null) { continue; } foreach (var filter in filters) { AddFilter(filter); } } } }
static void Main(string[] args) { var iisInvestigator = new IisInvestigator(); var server = iisInvestigator.Run(); var formatters = new List <IFormatter>(); //todo: use args to signal which formatters to use, custom file names, which reporters to use, etc formatters.Add(new ConsoleFormatter()); var machineName = string.Join("_", Environment.MachineName.Split(Path.GetInvalidFileNameChars(), StringSplitOptions.RemoveEmptyEntries)).TrimEnd('.'); var timestamp = DateTime.Now.ToString("yyyy-MM-dd_HH-mm-ss"); formatters.Add(new SpreadsheetFormatter(Environment.GetFolderPath(Environment.SpecialFolder.DesktopDirectory), $"{machineName}_forensic-report_{timestamp}.xlsx")); var formatterManager = new FormatterManager(formatters.ToArray()); var reporters = new IReporter[] { new SummaryReporter(), new AppPoolReporter(), new SiteReporter(), new DotNetReporter(), new DatabaseReporter(), new JavaScriptReporter() }; foreach (var reporter in reporters) { reporter.WriteReport(server, formatterManager); } formatterManager.End(); Console.ReadLine(); }
public void Write_read_and_compare_records() { var target = new SqlDatabaseClient(false) { ConnectionString = _connectionString }; var deleteDataCommand = @" DELETE [dbo].[Product]; DELETE [dbo].[Category]; DELETE [dbo].[Supplier]; "; target.ExecuteCommand(deleteDataCommand); var datasetXml = @" <dataset name=""suppliers"" setIdentityInsert=""true"" table=""Supplier""> <data> <row Id=""1"" Name=""supplier-1"" ContactName=""contact-name-1"" ContactPhone=""100-200-0001"" ContactEmail=""*****@*****.**"" /> <row Id=""2"" Name=""supplier-2"" ContactName=""contact-name-2"" ContactPhone=""100-200-0002"" ContactEmail=""*****@*****.**"" /> <row Id=""3"" Name=""supplier-3"" ContactName=""contact-name-3"" ContactPhone=""100-200-0003"" ContactEmail=""*****@*****.**"" /> </data> </dataset> "; var xml = XElement.Parse(datasetXml); var dataset = DatasetElement.Load(xml); target.WriteTable(dataset); var formatterManager = new FormatterManager(); var selectRecordsQuery = "SELECT * FROM [dbo].[Supplier];"; var actual = target.ReadTable(selectRecordsQuery, formatterManager); DbSafeManagerHelper.CompareDatasets(dataset, actual, new string[] { "Id" }, false, false); }
private void CreateSubFormatterFields() { _subFormatters = new Dictionary <FieldBase, FieldInfo>(); TypeBuilder helperBuilder = GeneratedAssembly.CreateType(_type.Name + "FormatterHelper"); Dictionary <string, Task <IFormatter> > values = new Dictionary <string, Task <IFormatter> >(); Dictionary <string, FieldBase> fieldMap = new Dictionary <string, FieldBase>(); foreach (FieldBase field in _fields) { Task <IFormatter> formatterTask = FormatterManager.GetFormatterAsync(field.Type, field.Type.IsAbstract); Type fieldType = typeof(Task <IFormatter>); string fieldName = String.Format("_0x{0}_formatter", field.ID.ToString("x2")); FieldBuilder cachedFormatterField = helperBuilder.DefineField(fieldName, fieldType, FieldAttributes.Static | FieldAttributes.Public); values.Add(cachedFormatterField.Name, formatterTask); fieldMap.Add(cachedFormatterField.Name, field); } FieldBuilder keyListFieldBuilder = helperBuilder.DefineField("_fieldIDs", typeof(List <int>), FieldAttributes.Static | FieldAttributes.Public); Type helperType = helperBuilder.CreateType(); foreach (KeyValuePair <string, Task <IFormatter> > pair in values) { FieldInfo realFieldInfo = helperType.GetField(pair.Key); realFieldInfo.SetValue(null, pair.Value); _subFormatters.Add(fieldMap[pair.Key], realFieldInfo); } _keyListField = helperType.GetField(keyListFieldBuilder.Name); List <int> keys = _fields.Select(f => f.ID).ToList(); _keyListField.SetValue(null, keys); }
public void Write_read_and_compare_records() { var datasetXml = @" <dataset name=""suppliers"" setIdentityInsert=""true"" table=""Supplier""> <data> <row id=""1"" name=""supplier-1"" contact_name=""contact-name-1"" contact_phone=""100-200-0001"" contact_email=""*****@*****.**"" /> <row id=""2"" name=""supplier-2"" contact_name=""contact-name-2"" contact_phone=""100-200-0002"" contact_email=""*****@*****.**"" /> <row id=""3"" name=""supplier-3"" contact_name=""contact-name-3"" contact_phone=""100-200-0003"" contact_email=""*****@*****.**"" /> </data> </dataset> "; var xml = XElement.Parse(datasetXml); var dataset = DatasetElement.Load(xml); _target.WriteTable(dataset); var formatterManager = new FormatterManager(); var selectRecordsQuery = "SELECT * FROM public.supplier;"; var actual = _target.ReadTable(selectRecordsQuery, formatterManager); DbSafeManagerHelper.CompareDatasets(dataset, actual, new string[] { "id" }, false, false); }
public void Write_Read_And_Compare_Results() { var client = new SqlDatabaseClient(false) { ConnectionString = connectionString }; var deleteCmd = @" DELETE FROM public.product; DELETE FROM public.category; DELETE FROM public.supplier; "; client.ExecuteCommand(deleteCmd); var expectedDatasetJson = @" { ""name"": ""suppliers"", ""table"": ""Supplier"", ""rows"": [ { ""columns"": [ { ""name"": ""id"", ""value"": ""1"" }, { ""name"": ""name"", ""value"": ""supplier-1"" }, { ""name"": ""contact_name"", ""value"": ""contact-name-1"" }, { ""name"": ""contact_phone"", ""value"": ""100-200-0001"" }, { ""name"": ""contact_email"", ""value"": ""*****@*****.**"" } ] }, { ""columns"": [ { ""name"": ""id"", ""value"": ""2"" }, { ""name"": ""name"", ""value"": ""supplier-2"" }, { ""name"": ""contact_name"", ""value"": ""contact-name-2"" }, { ""name"": ""contact_phone"", ""value"": ""100-200-0002"" }, { ""name"": ""contact_email"", ""value"": ""*****@*****.**"" } ] }, { ""columns"": [ { ""name"": ""id"", ""value"": ""3"" }, { ""name"": ""name"", ""value"": ""supplier-3"" }, { ""name"": ""contact_name"", ""value"": ""contact-name-3"" }, { ""name"": ""contact_phone"", ""value"": ""100-200-0003"" }, { ""name"": ""contact_email"", ""value"": ""*****@*****.**"" } ] } ] } "; var jsonDoc = JsonDocument.Parse(expectedDatasetJson); var expectedDataset = Dataset.Parse(jsonDoc.RootElement); client.InsertTableData(expectedDataset); var formatterManager = new FormatterManager(); var selectQuery = "SELECT * FROM public.supplier;"; var actualDataset = client.ReadTableData(selectQuery, formatterManager); expectedDataset.Rows.Should().BeEquivalentTo(actualDataset.Rows); }
public static Object.Collections.DataCollection BuildDataCollection(string connectionString, string tableName, IEnumerable <string> fields, IEnumerable <FieldFilter> filters, FormatterManager formatter) { var rows = new List <Object.Collections.DataRow>(); var command = $"SELECT {string.Join(",", fields)} FROM {tableName}"; if (filters != null && filters.Any()) { filters = SpecflowDbValidatorHelper.AddQuotationMarks(filters); var filtering = new List <string>(); foreach (var filter in filters) { filtering.Add($"{filter.FieldName} IN ({filter.FieldValues})"); } command = $"{command}{Environment.NewLine}{"WHERE"} {string.Join(" AND ", filtering)}"; } using (var conn = CreateDbConnection(connectionString)) { using (var comm = CreateDbCommand(command, conn)) { conn.Open(); var reader = comm.ExecuteReader(CommandBehavior.KeyInfo); while (reader.Read()) { var dataRow = new Object.Collections.DataRow(); rows.Add(dataRow); var dataCells = new List <Object.Collections.DataCell>(); for (int i = 0; i < reader.FieldCount; i++) { var columnName = reader.GetName(i); var dbValue = reader[i]; var value = dbValue.GetType() == typeof(DBNull) ? null : formatter.Format(tableName, columnName, dbValue); var cell = new KeyValuePair <string, string>(columnName, value); var dataCell = Object.Collections.DataCell.Load(cell); dataCells.Add(dataCell); } dataRow.Values = dataCells.ToArray(); } } } return(new Object.Collections.DataCollection { Rows = rows.ToArray(), }); }
public SqlSteps(string connectionString, FormatterManager formatter = null) : base( BuildPopulator(connectionString), BuildValidator(connectionString, formatter)) { }
private static SpecflowDbValidator <SqlConnection, SqlCommand> BuildValidator(string connectionString, FormatterManager formatter) { return(new SpecflowDbValidator <SqlConnection, SqlCommand>(new SqlSpecflowDbSchema(connectionString), formatter)); }
static DatabaseTestSteps() { _formatter = new FormatterManager(); // Adding formatters if needed. // _formatter.Register(typeof(decimal), new DecimalFormatter("0.00")); }