public async Task InitializeSessionExists()
{
// Setup: Create an edit data service with a session already defined
var eds = new EditDataService(null, null, null);
var session = await GetDefaultSession();
eds.ActiveSessions[Constants.OwnerUri] = session;
// If: I request to init a session for an owner URI that already exists
var initParams = new EditInitializeParams
{
ObjectName = "testTable",
OwnerUri = Constants.OwnerUri,
ObjectType = "Table",
Filters = new EditInitializeFiltering()
};
var efv = new EventFlowValidator <EditInitializeResult>()
.AddStandardErrorValidation()
.Complete();
await eds.HandleInitializeRequest(initParams, efv.Object);
// Then:
// ... An error event should have been sent
efv.Validate();
// ... The original session should still be there
Assert.Equal(1, eds.ActiveSessions.Count);
Assert.Equal(session, eds.ActiveSessions[Constants.OwnerUri]);
}
[InlineData(Common.OwnerUri, "table", null)] // Null object type
public async Task InitializeNullParams(string ownerUri, string objName, string objType)
{
// Setup: Create an edit data service without a session
var eds = new EditDataService(null, null, null);
// If:
// ... I have init params with a null parameter
var initParams = new EditInitializeParams
{
ObjectName = objName,
OwnerUri = ownerUri,
ObjectType = objType
};
// ... And I initialize an edit session with that
var efv = new EventFlowValidator <EditInitializeResult>()
.AddStandardErrorValidation()
.Complete();
await eds.HandleInitializeRequest(initParams, efv.Object);
// Then:
// ... An error event should have been raised
efv.Validate();
// ... There should not be a session
Assert.Empty(eds.ActiveSessions);
}
public async Task UpdateSuccess()
{
// Setup: Create an edit data service with a session
var eds = new EditDataService(null, null, null);
var session = await GetDefaultSession();
eds.ActiveSessions[Constants.OwnerUri] = session;
var edit = new Mock <RowEditBase>();
edit.Setup(e => e.SetCell(It.IsAny <int>(), It.IsAny <string>())).Returns(new EditUpdateCellResult
{
IsRowDirty = true,
Cell = new EditCell(new DbCellValue(), true)
});
session.EditCache[0] = edit.Object;
// If: I validly ask to update a cell
var efv = new EventFlowValidator <EditUpdateCellResult>()
.AddResultValidation(eucr =>
{
Assert.NotNull(eucr);
Assert.NotNull(eucr.Cell);
Assert.True(eucr.IsRowDirty);
})
.Complete();
await eds.HandleUpdateCellRequest(new EditUpdateCellParams { OwnerUri = Constants.OwnerUri, RowId = 0 }, efv.Object);
// Then:
// ... It should be successful
efv.Validate();
// ... Set cell should have been called once
edit.Verify(e => e.SetCell(It.IsAny <int>(), It.IsAny <string>()), Times.Once);
}
public async Task GetRowsSuccess()
{
// Setup: Create an edit data service with a session
// Setup: Create an edit data service with a session
var eds = new EditDataService(null, null, null);
var session = await GetDefaultSession();
eds.ActiveSessions[Constants.OwnerUri] = session;
// If: I validly ask for rows
var efv = new EventFlowValidator <EditSubsetResult>()
.AddResultValidation(esr =>
{
Assert.NotNull(esr);
Assert.NotEmpty(esr.Subset);
Assert.NotEqual(0, esr.RowCount);
})
.Complete();
await eds.HandleSubsetRequest(new EditSubsetParams
{
OwnerUri = Constants.OwnerUri,
RowCount = 10,
RowStartIndex = 0
}, efv.Object);
// Then:
// ... It should be successful
efv.Validate();
}
public async Task DisposeNullOrMissingSessionId(string sessionId)
{
// Setup: Create a edit data service
var eds = new EditDataService(null, null, null);
// If: I ask to perform an action that requires a session
// Then: I should get an error from it
var efv = new EventFlowValidator <EditDisposeResult>()
.AddStandardErrorValidation()
.Complete();
await eds.HandleDisposeRequest(new EditDisposeParams { OwnerUri = sessionId }, efv.Object);
efv.Validate();
}
public async Task NullOrMissingSessionId(string sessionId)
{
// Setup:
// ... Create a edit data service
var eds = new EditDataService(null, null, null);
// ... Create a session params that returns the provided session ID
var mockParams = new EditCreateRowParams {
OwnerUri = sessionId
};
// If: I ask to perform an action that requires a session
// Then: I should get an error from it
var efv = new EventFlowValidator <EditDisposeResult>()
.AddStandardErrorValidation()
.Complete();
await eds.HandleSessionRequest(mockParams, efv.Object, session => null);
efv.Validate();
}
public async Task DisposeSuccess()
{
// Setup: Create an edit data service with a session
var eds = new EditDataService(null, null, null);
eds.ActiveSessions[Common.OwnerUri] = await GetDefaultSession();
// If: I ask to dispose of an existing session
var efv = new EventFlowValidator <EditDisposeResult>()
.AddResultValidation(Assert.NotNull)
.Complete();
await eds.HandleDisposeRequest(new EditDisposeParams { OwnerUri = Common.OwnerUri }, efv.Object);
// Then:
// ... It should have completed successfully
efv.Validate();
// ... And the session should have been removed from the active session list
Assert.Empty(eds.ActiveSessions);
}
[InlineData("schema.table", null, new [] { "schema", "table" })] // Split object name into schema
public void ShouldUseSchemaNameIfDefined(string objName, string schemaName, string[] expectedNameParts)
{
// Setup: Create an edit data service without a session
var eds = new EditDataService(null, null, null);
// If:
// ... I have init params with an object and schema parameter
var initParams = new EditInitializeParams
{
ObjectName = objName,
SchemaName = schemaName,
OwnerUri = Common.OwnerUri,
ObjectType = "table"
};
// ... And I get named parts for that
string[] nameParts = EditSession.GetEditTargetName(initParams);
// Then:
Assert.Equal(expectedNameParts, nameParts);
}
public async Task OperationThrows()
{
// Setup:
// ... Create an edit data service with a session
var eds = new EditDataService(null, null, null);
eds.ActiveSessions[Common.OwnerUri] = await GetDefaultSession();
// ... Create a session param that returns the common owner uri
var mockParams = new EditCreateRowParams {
OwnerUri = Common.OwnerUri
};
// If: I ask to perform an action that requires a session
// Then: I should get an error from it
var efv = new EventFlowValidator <EditDisposeResult>()
.AddStandardErrorValidation()
.Complete();
await eds.HandleSessionRequest(mockParams, efv.Object, s => { throw new Exception(); });
efv.Validate();
}
public async Task CreateSucceeds()
{
// Setup: Create an edit data service with a session
var eds = new EditDataService(null, null, null);
eds.ActiveSessions[Constants.OwnerUri] = await GetDefaultSession();
// If: I ask to create a row from a non existant session
var efv = new EventFlowValidator <EditCreateRowResult>()
.AddResultValidation(ecrr => { Assert.True(ecrr.NewRowId > 0); })
.Complete();
await eds.HandleCreateRowRequest(new EditCreateRowParams { OwnerUri = Constants.OwnerUri }, efv.Object);
// Then:
// ... It should have been successful
efv.Validate();
// ... There should be a create in the session
EditSession s = eds.ActiveSessions[Constants.OwnerUri];
Assert.True(s.EditCache.Any(e => e.Value is RowCreate));
}
public async Task DeleteSuccess()
{
// Setup: Create an edit data service with a session
var eds = new EditDataService(null, null, null);
eds.ActiveSessions[Constants.OwnerUri] = await GetDefaultSession();
// If: I validly ask to delete a row
var efv = new EventFlowValidator <EditDeleteRowResult>()
.AddResultValidation(Assert.NotNull)
.Complete();
await eds.HandleDeleteRowRequest(new EditDeleteRowParams { OwnerUri = Constants.OwnerUri, RowId = 0 }, efv.Object);
// Then:
// ... It should be successful
efv.Validate();
// ... There should be a delete in the session
EditSession s = eds.ActiveSessions[Constants.OwnerUri];
Assert.True(s.EditCache.Any(e => e.Value is RowDelete));
}
public async Task RevertCellSucceeds()
{
// Setup:
// ... Create an edit data service with a session that has a pending cell edit
var eds = new EditDataService(null, null, null);
var session = await GetDefaultSession();
eds.ActiveSessions[Constants.OwnerUri] = session;
// ... Make sure that the edit has revert capabilities
var mockEdit = new Mock <RowEditBase>();
mockEdit.Setup(edit => edit.RevertCell(It.IsAny <int>()))
.Returns(new EditRevertCellResult());
session.EditCache[0] = mockEdit.Object;
// If: I ask to revert a cell that has a pending edit
var efv = new EventFlowValidator <EditRevertCellResult>()
.AddResultValidation(Assert.NotNull)
.Complete();
var param = new EditRevertCellParams
{
OwnerUri = Constants.OwnerUri,
RowId = 0
};
await eds.HandleRevertCellRequest(param, efv.Object);
// Then:
// ... It should have succeeded
efv.Validate();
// ... The edit cache should be empty again
EditSession s = eds.ActiveSessions[Constants.OwnerUri];
Assert.Empty(s.EditCache);
}
public async Task RevertRowSucceeds()
{
// Setup: Create an edit data service with a session that has an pending edit
var eds = new EditDataService(null, null, null);
var session = await GetDefaultSession();
session.EditCache[0] = new Mock <RowEditBase>().Object;
eds.ActiveSessions[Constants.OwnerUri] = session;
// If: I ask to revert a row that has a pending edit
var efv = new EventFlowValidator <EditRevertRowResult>()
.AddResultValidation(Assert.NotNull)
.Complete();
await eds.HandleRevertRowRequest(new EditRevertRowParams { OwnerUri = Constants.OwnerUri, RowId = 0 }, efv.Object);
// Then:
// ... It should have succeeded
efv.Validate();
// ... The edit cache should be empty again
EditSession s = eds.ActiveSessions[Constants.OwnerUri];
Assert.Empty(s.EditCache);
}
public async Task InitializeSessionSuccess()
{
// Setup:
// .. Create a mock query
var mockQueryResults = QueryExecution.Common.StandardTestDataSet;
var cols = mockQueryResults[0].Columns;
// ... Create a metadata factory that will return some generic column information
var etm = Common.GetStandardMetadata(cols.ToArray());
Mock <IEditMetadataFactory> emf = new Mock <IEditMetadataFactory>();
emf.Setup(f => f.GetObjectMetadata(It.IsAny <DbConnection>(), It.IsAny <string[]>(), It.IsAny <string>()))
.Returns(etm);
// ... Create a query execution service that will return a successful query
var qes = QueryExecution.Common.GetPrimedExecutionService(mockQueryResults, true, false, false, null);
// ... Create a connection service that doesn't throw when asked for a connection
var cs = new Mock <ConnectionService>();
cs.Setup(s => s.GetOrOpenConnection(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <bool>()))
.Returns(Task.FromResult <DbConnection>(null));
// ... Create an edit data service that has mock providers
var eds = new EditDataService(qes, cs.Object, emf.Object);
// If: I request to initialize an edit data session
var initParams = new EditInitializeParams
{
ObjectName = "testTable",
OwnerUri = Constants.OwnerUri,
ObjectType = "Table",
Filters = new EditInitializeFiltering()
};
var efv = new EventFlowValidator <EditInitializeResult>()
.AddResultValidation(Assert.NotNull)
.AddEventValidation(BatchStartEvent.Type, Assert.NotNull)
.AddEventValidation(ResultSetCompleteEvent.Type, Assert.NotNull)
.AddEventValidation(MessageEvent.Type, Assert.NotNull)
.AddEventValidation(BatchCompleteEvent.Type, Assert.NotNull)
.AddEventValidation(QueryCompleteEvent.Type, Assert.NotNull)
.AddEventValidation(EditSessionReadyEvent.Type, esrp =>
{
Assert.NotNull(esrp);
Assert.Equal(Constants.OwnerUri, esrp.OwnerUri);
Assert.True(esrp.Success);
Assert.Null(esrp.Message);
})
.Complete();
await eds.HandleInitializeRequest(initParams, efv.Object);
await eds.ActiveSessions[Constants.OwnerUri].InitializeTask;
// Then:
// ... The event should have been received successfully
efv.Validate();
// ... The session should have been created
Assert.Equal(1, eds.ActiveSessions.Count);
Assert.True(eds.ActiveSessions.Keys.Contains(Constants.OwnerUri));
}
