public void ExistingFeatureIsUpdatedCorrectly()
{
string messageId = Guid.NewGuid().ToString();
Guid space = Guid.NewGuid();
Guid owner = Guid.NewGuid();
FeatureKey featureQuery = FeatureKey.Create(1, owner, space);
Feature storedFeature = Feature.Create(1, owner, space, FeatureName);
Feature updatedFeature = Feature.Create(1, owner, space, FeatureName);
updatedFeature.Enabled = true;
StandardFeatureStore standardFeatureStore = new StandardFeatureStore(m_StorageContainer);
UpdateFeatureStateRequest request = UpdateFeatureStateRequest.Create(messageId, featureQuery, true);
using (m_MockRepository.Record())
{
Expect.Call(m_StorageContainer.Retrieve(featureQuery)).Return(storedFeature);
Expect.Call(m_StorageContainer.Store(storedFeature)).Return(updatedFeature);
m_MockRepository.ReplayAll();
UpdateFeatureStateResponse response = standardFeatureStore.UpdateFeatureState(request);
Assert.AreEqual(messageId, response.Header.MessageId);
Assert.AreEqual(1, response.Result.Id);
Assert.AreEqual(space, response.Result.Space);
Assert.IsTrue(response.Result.Enabled);
m_MockRepository.VerifyAll();
}
}
public void ProxyCanCallUpdateFeatureStateSynchronously()
{
const string messageId = "ProxyCanCallUpdateFeatureStateSynchronously";
UpdateFeatureStateRequest request = BuildUpdateFeatureStateRequestWithSavedFeature(messageId);
UpdateFeatureStateResponse response = m_FeatureStoreServiceProxy.UpdateFeatureState(request);
AssertUpdateFeatureStateValues(request, response);
}
private static void AssertUpdateFeatureStateValues(UpdateFeatureStateRequest request,
UpdateFeatureStateResponse response)
{
Assert.AreEqual(request.Header.MessageId, response.Header.MessageId);
Assert.AreEqual(request.Key.Id, response.Result.Id);
Assert.AreEqual(request.Key.OwnerId, response.Result.OwnerId);
Assert.AreEqual(request.Key.Space, response.Result.Space);
Assert.AreEqual(request.NewState, response.Result.Enabled);
}
public void ProxyCanCallUpdateFeatureStateAsynchronouslyWithBlocking()
{
const string messageId = "ProxyCanCallUpdateFeatureStateAsynchronouslyWithBlocking";
UpdateFeatureStateRequest request = BuildUpdateFeatureStateRequestWithSavedFeature(messageId);
IAsyncResult result = m_FeatureStoreServiceProxy.BeginUpdateFeatureState(request, null, null);
result.AsyncWaitHandle.WaitOne();
UpdateFeatureStateResponse response = m_FeatureStoreServiceProxy.EndUpdateFeatureState(result);
AssertUpdateFeatureStateValues(request, response);
}
public void ProxyCanCallUpdateFeatureStateAsynchronouslyWithPolling()
{
const string messageId = "ProxyCanCallUpdateFeatureStateAsynchronouslyWithPolling";
UpdateFeatureStateRequest request = BuildUpdateFeatureStateRequestWithSavedFeature(messageId);
IAsyncResult result = m_FeatureStoreServiceProxy.BeginUpdateFeatureState(request, null, null);
while (!result.IsCompleted)
{
}
UpdateFeatureStateResponse response = m_FeatureStoreServiceProxy.EndUpdateFeatureState(result);
AssertUpdateFeatureStateValues(request, response);
}
/// <summary>
/// Builds the results rich text.
/// </summary>
/// <param name = "request">The request.</param>
/// <param name = "response">The response.</param>
/// <param name = "commandName"></param>
/// <returns></returns>
protected static string BuildResultsRichText(UpdateFeatureStateRequest request,
UpdateFeatureStateResponse response, string commandName)
{
StringBuilder builder = new StringBuilder(RtfResources.RTF_PREAMBLE);
builder.AppendFormat(CultureInfo.CurrentUICulture, RtfResources.RTF_HEADER_FORMAT, commandName);
builder.Append(RtfResources.REQUEST_SECTION);
builder.Append(BuildMessageHeaderRichText(request.Header));
builder.Append(BuildFeatureKeyRichText(request.Key));
builder.Append(RtfResources.RESPONSE_SECTION);
builder.Append(BuildMessageHeaderRichText(response.Header));
builder.Append(BuildFeatureRichText(response.Result));
builder.Append(RtfResources.RTF_CLOSE);
return(builder.ToString());
}
/// <summary>
/// Updates the state of a specified feature.
/// </summary>
/// <param name = "request"><see cref = "UpdateFeatureStateRequest" /> instance that defines the state necessary to update a specified Feature.</param>
/// <returns>
/// <see cref = "UpdateFeatureStateResponse" /> containing the results of the request to update the state of a specified Feature.
/// </returns>
public UpdateFeatureStateResponse UpdateFeatureState(UpdateFeatureStateRequest request)
{
UpdateFeatureStateResponse response;
using (PerformanceCounterReporterFactory.CreateReporter(PerformanceCounterReporterType.UpdateFeatureState))
{
Feature updatedFeature;
try
{
Feature feature = m_StorageContainer.Retrieve(request.Key);
if (feature == null)
{
throw new UpdateFeatureStateException(
string.Format(
CultureInfo.CurrentUICulture,
ExceptionMessageResources.FEATURE_NOT_FOUND,
request.Key.Id,
request.Key.Space));
}
feature.Enabled = request.NewState;
updatedFeature = m_StorageContainer.Store(feature);
}
catch (Exception e)
{
UpdateFeatureStateException updateFeatureStateException =
new UpdateFeatureStateException(
string.Format(
CultureInfo.CurrentUICulture,
ExceptionMessageResources.UPDATE_FEATURE_STATE_EXCEPTION,
request.Key.Id,
request.Key.Space),
e);
m_Logger.Error(updateFeatureStateException);
throw updateFeatureStateException;
}
response = UpdateFeatureStateResponse.Create(request.Header.MessageId, updatedFeature);
LogInteraction(request, response);
}
return(response);
}
public void Execute(IServiceMethodUiBridge serviceMethodUiBridge)
{
m_ServiceMethodUiBridge = serviceMethodUiBridge;
AsyncOperation asyncOperation = AsyncOperationManager.CreateOperation(m_AsyncKey);
try
{
FeatureKey featureKey = BuildFeatureKey(serviceMethodUiBridge);
UpdateFeatureStateRequest request = UpdateFeatureStateRequest.Create(
MessageIdFactory.GenerateMessageId(),
featureKey,
serviceMethodUiBridge.FeatureStoreMethodArguments.State);
IFeatureStoreServiceProxy featureStoreServiceProxy = new FeatureStoreServiceProxy();
featureStoreServiceProxy.BeginUpdateFeatureState(
request,
ar =>
{
string rtfResults;
try
{
UpdateFeatureStateResponse response =
featureStoreServiceProxy.EndUpdateFeatureState(ar);
rtfResults = BuildResultsRichText(request, response, GetType().Name);
}
catch (Exception e)
{
rtfResults = BuildExceptionRichText(e);
}
asyncOperation.PostOperationCompleted(HandleEndAsync, rtfResults);
},
null);
}
catch (Exception e)
{
serviceMethodUiBridge.DisplayResults(BuildExceptionRichText(e));
}
}
public void ProxyCanCallUpdateFeatureStateAsynchronouslyWithCallback()
{
const string messageId = "ProxyCanCallUpdateFeatureStateAsynchronouslyWithCallback";
ManualResetEvent resetEvent = new ManualResetEvent(false);
UpdateFeatureStateResponse response = null;
UpdateFeatureStateRequest request = BuildUpdateFeatureStateRequestWithSavedFeature(messageId);
m_FeatureStoreServiceProxy.BeginUpdateFeatureState(
request,
r =>
{
response = m_FeatureStoreServiceProxy.EndUpdateFeatureState(r);
resetEvent.Set();
},
null);
resetEvent.WaitOne();
AssertUpdateFeatureStateValues(request, response);
}
public void Execute(IServiceMethodUiBridge serviceMethodUiBridge)
{
FeatureKey featureKey = BuildFeatureKey(serviceMethodUiBridge);
try
{
UpdateFeatureStateRequest request = UpdateFeatureStateRequest.Create(
MessageIdFactory.GenerateMessageId(),
featureKey,
serviceMethodUiBridge.FeatureStoreMethodArguments.State);
IFeatureStoreServiceProxy featureStoreServiceProxy = new FeatureStoreServiceProxy();
UpdateFeatureStateResponse response = featureStoreServiceProxy.UpdateFeatureState(request);
serviceMethodUiBridge.DisplayResults(BuildResultsRichText(request, response, GetType().Name));
}
catch (Exception e)
{
serviceMethodUiBridge.DisplayResults(BuildExceptionRichText(e));
}
}
public void ExerciseFullInterface()
{
Debug.WriteLine("BEGIN: ExerciseFullInterface");
CacheSwappingStorageContainer cacheSwappingStorageContainer =
new CacheSwappingStorageContainer(@".\ExerciseFullInterface_Storage.dat");
StandardFeatureStore standardFeatureStore = new StandardFeatureStore(cacheSwappingStorageContainer);
/* -- CreateFeature -- */
CreateFeatureRequest createFeatureRequest1 = CreateFeatureRequest.Create(
Guid.NewGuid().ToString(),
Feature.Create(
1,
Guid.NewGuid(),
Guid.NewGuid(),
"Feature One"));
CreateFeatureRequest createFeatureRequest2 = CreateFeatureRequest.Create(
Guid.NewGuid().ToString(),
Feature.Create(
2,
Guid.NewGuid(),
Guid.NewGuid(),
"Feature Two"));
CreateFeatureRequest createFeatureRequest3 = CreateFeatureRequest.Create(
Guid.NewGuid().ToString(),
Feature.Create(
3,
Guid.NewGuid(),
Guid.NewGuid(),
"Feature Three"));
CreateFeatureResponse createFeatureResponse = standardFeatureStore.CreateFeature(createFeatureRequest1);
AssertCreateFeatureResponse(createFeatureRequest1, createFeatureResponse);
createFeatureResponse = standardFeatureStore.CreateFeature(createFeatureRequest2);
AssertCreateFeatureResponse(createFeatureRequest2, createFeatureResponse);
createFeatureResponse = standardFeatureStore.CreateFeature(createFeatureRequest3);
AssertCreateFeatureResponse(createFeatureRequest3, createFeatureResponse);
AssertPerformanceCountersRecorded(PerformanceCounterReporterType.CreateFeature, false, 3);
/* -- CheckFeatureState -- */
CheckFeatureStateRequest checkFeatureStateRequest1 =
CheckFeatureStateRequest.Create(
Guid.NewGuid().ToString(),
FeatureKey.Create(
createFeatureRequest1.Feature.Id,
createFeatureRequest1.Feature.OwnerId,
createFeatureRequest1.Feature.Space));
CheckFeatureStateResponse checkFeatureStateResponse =
standardFeatureStore.CheckFeatureState(checkFeatureStateRequest1);
AssertCheckFeatureStateResponse(checkFeatureStateRequest1, checkFeatureStateResponse);
CheckFeatureStateRequest checkFeatureStateRequest2 =
CheckFeatureStateRequest.Create(
Guid.NewGuid().ToString(),
FeatureKey.Create(
createFeatureRequest2.Feature.Id,
createFeatureRequest2.Feature.OwnerId,
createFeatureRequest2.Feature.Space));
checkFeatureStateResponse = standardFeatureStore.CheckFeatureState(checkFeatureStateRequest2);
AssertCheckFeatureStateResponse(checkFeatureStateRequest2, checkFeatureStateResponse);
CheckFeatureStateRequest checkFeatureStateRequest3 =
CheckFeatureStateRequest.Create(
Guid.NewGuid().ToString(),
FeatureKey.Create(
createFeatureRequest3.Feature.Id,
createFeatureRequest3.Feature.OwnerId,
createFeatureRequest3.Feature.Space));
checkFeatureStateResponse = standardFeatureStore.CheckFeatureState(checkFeatureStateRequest3);
AssertCheckFeatureStateResponse(checkFeatureStateRequest3, checkFeatureStateResponse);
AssertPerformanceCountersRecorded(PerformanceCounterReporterType.CheckFeatureState, false, 3);
/* -- UpdateFeatureState -- */
UpdateFeatureStateRequest updateFeatureStateRequest1 =
UpdateFeatureStateRequest.Create(
Guid.NewGuid().ToString(),
FeatureKey.Create(
createFeatureRequest1.Feature.Id,
createFeatureRequest1.Feature.OwnerId,
createFeatureRequest1.Feature.Space),
true);
UpdateFeatureStateResponse updateFeatureStateResponse =
standardFeatureStore.UpdateFeatureState(updateFeatureStateRequest1);
Assert.IsTrue(updateFeatureStateResponse.Result.Enabled);
UpdateFeatureStateRequest updateFeatureStateRequest2 =
UpdateFeatureStateRequest.Create(
Guid.NewGuid().ToString(),
FeatureKey.Create(
createFeatureRequest2.Feature.Id,
createFeatureRequest2.Feature.OwnerId,
createFeatureRequest2.Feature.Space),
true);
updateFeatureStateResponse = standardFeatureStore.UpdateFeatureState(updateFeatureStateRequest2);
Assert.IsTrue(updateFeatureStateResponse.Result.Enabled);
UpdateFeatureStateRequest updateFeatureStateRequest3 =
UpdateFeatureStateRequest.Create(
Guid.NewGuid().ToString(),
FeatureKey.Create(
createFeatureRequest3.Feature.Id,
createFeatureRequest3.Feature.OwnerId,
createFeatureRequest3.Feature.Space),
true);
updateFeatureStateResponse = standardFeatureStore.UpdateFeatureState(updateFeatureStateRequest3);
Assert.IsTrue(updateFeatureStateResponse.Result.Enabled);
AssertPerformanceCountersRecorded(PerformanceCounterReporterType.UpdateFeatureState, false, 3);
/* -- RetrieveDefinedFeatures -- */
RetrieveDefinedFeaturesRequest retrieveDefinedFeaturesRequest = RetrieveDefinedFeaturesRequest.Create(
Guid.NewGuid().ToString(),
FeatureScope.Create(createFeatureRequest1.Feature.OwnerId, createFeatureRequest1.Feature.Space));
RetrieveDefinedFeaturesResponse retrieveDefinedFeaturesResponse =
standardFeatureStore.RetrieveDefinedFeatures(retrieveDefinedFeaturesRequest);
Assert.IsNotNull(retrieveDefinedFeaturesResponse.Result);
Assert.IsTrue(retrieveDefinedFeaturesResponse.Result.GetEnumerator().MoveNext());
AssertPerformanceCountersRecorded(PerformanceCounterReporterType.RetrieveDefinedFeatures, true, 1);
Debug.WriteLine("END: ExerciseFullInterface");
}
