示例#1
0
 /// <summary>
 /// Constructor, stores the Excel specific request params locally, chains into the base
 /// constructor
 /// </summary>
 /// <param name="stream">FileStream to access the Excel file output</param>
 /// <param name="requestParams">Excel save as request parameters</param>
 public SaveAsExcelFileStreamWriter(Stream stream, SaveResultsAsExcelRequestParams requestParams)
     : base(stream, requestParams)
 {
     saveParams = requestParams;
     helper     = new SaveAsExcelFileStreamWriterHelper(stream);
     sheet      = helper.AddSheet();
 }
示例#2
0
        /// <summary>
        /// Process request to save a resultSet to a file in Excel format
        /// </summary>
        internal async Task HandleSaveResultsAsExcelRequest(SaveResultsAsExcelRequestParams saveParams,
                                                            RequestContext <SaveResultRequestResult> requestContext)
        {
            // Use the default Excel file factory if we haven't overridden it
            IFileStreamFactory excelFactory = ExcelFileFactory ?? new SaveAsExcelFileStreamFactory
            {
                SaveRequestParams      = saveParams,
                QueryExecutionSettings = Settings.QueryExecutionSettings
            };

            await SaveResultsHelper(saveParams, requestContext, excelFactory);
        }
示例#3
0
        private static IFileStreamFactory GetExcelStreamFactory(IDictionary <string, byte[]> storage,
                                                                SaveResultsAsExcelRequestParams saveParams)
        {
            Mock <IFileStreamFactory> mock = new Mock <IFileStreamFactory>();

            mock.Setup(fsf => fsf.GetReader(It.IsAny <string>()))
            .Returns <string>(output => new ServiceBufferFileStreamReader(new MemoryStream(storage[output]), new QueryExecutionSettings()));
            mock.Setup(fsf => fsf.GetWriter(It.IsAny <string>()))
            .Returns <string>(output =>
            {
                storage.Add(output, new byte[8192]);
                return(new SaveAsExcelFileStreamWriter(new MemoryStream(storage[output]), saveParams));
            });

            return(mock.Object);
        }
        public async Task SaveResultAsExcelFailure()
        {
            // Given:
            // ... A working query and workspace service
            WorkspaceService <SqlToolsSettings>   ws = Common.GetPrimedWorkspaceService(Constants.StandardQuery);
            ConcurrentDictionary <string, byte[]> storage;
            QueryExecutionService qes = Common.GetPrimedExecutionService(Common.StandardTestDataSet, true, false, false, ws, out storage);

            // ... The query execution service has executed a query with results
            var executeParams = new ExecuteDocumentSelectionParams {
                QuerySelection = null, OwnerUri = Constants.OwnerUri
            };
            var executeRequest = RequestContextMocks.Create <ExecuteRequestResult>(null);
            await qes.HandleExecuteRequest(executeParams, executeRequest.Object);

            await qes.WorkTask;
            await qes.ActiveQueries[Constants.OwnerUri].ExecutionTask;

            // If: I attempt to save a result set and get it to throw because of invalid column selection
            SaveResultsAsExcelRequestParams saveParams = new SaveResultsAsExcelRequestParams
            {
                BatchIndex       = 0,
                FilePath         = "qqq",
                OwnerUri         = Constants.OwnerUri,
                ResultSetIndex   = 0,
                ColumnStartIndex = -1,
                ColumnEndIndex   = 100,
                RowStartIndex    = 0,
                RowEndIndex      = 5
            };

            qes.JsonFileFactory = GetExcelStreamFactory(storage, saveParams);
            var efv = new EventFlowValidator <SaveResultRequestResult>()
                      .AddStandardErrorValidation()
                      .Complete();
            await qes.HandleSaveResultsAsExcelRequest(saveParams, efv.Object);

            await qes.ActiveQueries[saveParams.OwnerUri]
            .Batches[saveParams.BatchIndex]
            .ResultSets[saveParams.ResultSetIndex]
            .SaveTasks[saveParams.FilePath];

            // Then:
            // ... An error event should have been fired
            // ... No success event should have been fired
            efv.Validate();
        }
        public async Task SaveResultsAsExcelSuccess()
        {
            // Given:
            // ... A working query and workspace service
            WorkspaceService <SqlToolsSettings>   ws = Common.GetPrimedWorkspaceService(Constants.StandardQuery);
            ConcurrentDictionary <string, byte[]> storage;
            QueryExecutionService qes = Common.GetPrimedExecutionService(Common.StandardTestDataSet, true, false, false, ws, out storage);

            // ... The query execution service has executed a query with results
            var executeParams = new ExecuteDocumentSelectionParams {
                QuerySelection = null, OwnerUri = Constants.OwnerUri
            };
            var executeRequest = RequestContextMocks.Create <ExecuteRequestResult>(null);
            await qes.HandleExecuteRequest(executeParams, executeRequest.Object);

            await qes.WorkTask;
            await qes.ActiveQueries[Constants.OwnerUri].ExecutionTask;

            // If: I attempt to save a result set from a query
            SaveResultsAsExcelRequestParams saveParams = new SaveResultsAsExcelRequestParams
            {
                OwnerUri       = Constants.OwnerUri,
                FilePath       = "qqq",
                BatchIndex     = 0,
                ResultSetIndex = 0
            };

            qes.ExcelFileFactory = GetExcelStreamFactory(storage, saveParams);
            var efv = new EventFlowValidator <SaveResultRequestResult>()
                      .AddStandardResultValidator()
                      .Complete();
            await qes.HandleSaveResultsAsExcelRequest(saveParams, efv.Object);

            await qes.ActiveQueries[saveParams.OwnerUri]
            .Batches[saveParams.BatchIndex]
            .ResultSets[saveParams.ResultSetIndex]
            .SaveTasks[saveParams.FilePath];

            // Then:
            // ... I should have a successful result
            // ... There should not have been an error
            efv.Validate();
        }
示例#6
0
        public async Task SaveResultsExcelNonExistentQuery()
        {
            // Given: A working query and workspace service
            WorkspaceService <SqlToolsSettings> ws = Common.GetPrimedWorkspaceService(null);
            QueryExecutionService qes = Common.GetPrimedExecutionService(null, false, false, false, ws);

            // If: I attempt to save a result set from a query that doesn't exist
            SaveResultsAsExcelRequestParams saveParams = new SaveResultsAsExcelRequestParams
            {
                OwnerUri = Constants.OwnerUri  // Won't exist because nothing has executed
            };
            var efv = new EventFlowValidator <SaveResultRequestResult>()
                      .AddStandardErrorValidation()
                      .Complete();
            await qes.HandleSaveResultsAsExcelRequest(saveParams, efv.Object);

            // Then:
            // ... An error event should have been fired
            // ... No success event should have been fired
            efv.Validate();
        }