public void CheckFeatureStateThrowsFeatureStoreFaultExceptionOnException() { IStorageContainer storageContainer = m_MockRepository.StrictMock <IStorageContainer>(); FeatureKey key = FeatureKey.Create(1, Guid.NewGuid(), Guid.NewGuid()); using (m_MockRepository.Record()) { Expect.Call(storageContainer.Retrieve(FeatureKey.Create(key.Id, key.OwnerId, key.Space))).Throw( new CheckFeatureStateException("Bad Mojo Exception")); m_MockRepository.ReplayAll(); FeatureStoreService featureStoreService = new FeatureStoreService(storageContainer); try { featureStoreService.CheckFeatureState( CheckFeatureStateRequest.Create( "CheckFeatureStateThrowsFeatureStoreFaultExceptionOnException", key)); Assert.Fail("Expecting FaultException<FeatureStoreFault>"); } catch (FaultException <FeatureStoreFault> e) { Console.WriteLine(e.Detail.Message); Console.WriteLine(e.Message); StringAssert.Contains(e.Detail.Message, "An exception occurred querying the data store for the Feature."); } m_MockRepository.VerifyAll(); } }
/// <summary> /// Checks the state of an existing Feature. /// </summary> /// <param name = "request"><see cref = "CheckFeatureStateRequest" /> instance that defines the criteria by which the Feature will be queried.</param> /// <returns> /// <see cref = "CheckFeatureStateResponse" /> containing the results of the request for the state of a Feature. /// </returns> public CheckFeatureStateResponse CheckFeatureState(CheckFeatureStateRequest request) { CheckFeatureStateResponse response; using (PerformanceCounterReporterFactory.CreateReporter(PerformanceCounterReporterType.CheckFeatureState)) { Feature feature; try { feature = m_StorageContainer.Retrieve(request.Key); } catch (Exception e) { CheckFeatureStateException checkFeatureStateException = new CheckFeatureStateException( string.Format( CultureInfo.CurrentUICulture, ExceptionMessageResources.CHECK_FEATURE_STATE_EXCEPTION, request.Key.Id, request.Key.Space), e); m_Logger.Error(checkFeatureStateException); throw checkFeatureStateException; } response = CheckFeatureStateResponse.Create(request.Header.MessageId, feature); LogInteraction(request, response); } return(response); }
/// <summary> /// Asserts the check feature state response. /// </summary> /// <param name="request">The request.</param> /// <param name="response">The response.</param> /// <remarks></remarks> private static void AssertCheckFeatureStateResponse(CheckFeatureStateRequest request, CheckFeatureStateResponse response) { Assert.AreEqual(request.Header.MessageId, response.Header.MessageId); Assert.AreEqual(request.Key.Id, response.Result.Id); Assert.AreEqual(request.Key.Space, response.Result.Space); }
public void ExceptionIsRaisedAsCheckFeatureStateException() { string messageId = Guid.NewGuid().ToString(); Exception exception = m_MockRepository.StrictMock <Exception>(); FeatureKey query = FeatureKey.Create(-1, Guid.Empty, Guid.Empty); CheckFeatureStateRequest request = CheckFeatureStateRequest.Create(messageId, query); StandardFeatureStore standardFeatureStore = new StandardFeatureStore(m_StorageContainer); using (m_MockRepository.Record()) { Expect.Call(exception.Message).Return("Bad Mojo"); Expect.Call(m_StorageContainer.Retrieve(query)).Throw(exception); m_MockRepository.ReplayAll(); try { standardFeatureStore.CheckFeatureState(request); Assert.Fail("Expected CheckFeatureStateException"); } catch (CheckFeatureStateException e) { StringAssert.Contains(e.Message, "Id " + query.Id); StringAssert.Contains(e.Message, "Space " + query.Space); } m_MockRepository.VerifyAll(); } }
private static CheckFeatureStateRequest BuildCheckFeatureStateRequestWithSavedFeature(string messageId) { Feature feature = Feature.Create(1, Guid.NewGuid(), Guid.NewGuid(), "CheckFeatureStateFeature"); AddFeatureToStorage(messageId, feature); return(CheckFeatureStateRequest.Create(messageId, FeatureKey.Create(feature.Id, feature.OwnerId, feature.Space))); }
private static void AssertCheckFeatureStateValues(CheckFeatureStateRequest request, CheckFeatureStateResponse response) { Assert.IsNotNull(response.Result); Assert.AreEqual(request.Key.Id, response.Result.Id); Assert.AreEqual(request.Key.OwnerId, response.Result.OwnerId); Assert.AreEqual(request.Key.Space, response.Result.Space); }
public void ProxyCanCallCheckFeatureStateSynchronously() { CheckFeatureStateRequest request = BuildCheckFeatureStateRequestWithSavedFeature("ProxyCanCallCheckFeatureStateSynchronously"); CheckFeatureStateResponse response = m_FeatureStoreServiceProxy.CheckFeatureState(request); Assert.IsNotNull(response.Result); Assert.AreEqual(request.Key.Id, response.Result.Id); Assert.AreEqual(request.Key.OwnerId, response.Result.OwnerId); Assert.AreEqual(request.Key.Space, response.Result.Space); }
public void ProxyCanCallCheckFeatureStateAsynchronouslyWithBlocking() { const string messageId = "ProxyCanCallCheckFeatureStateAsynchronouslyWithPolling"; CheckFeatureStateRequest request = BuildCheckFeatureStateRequestWithSavedFeature(messageId); IAsyncResult result = m_FeatureStoreServiceProxy.BeginCheckFeatureState(request, null, null); result.AsyncWaitHandle.WaitOne(); CheckFeatureStateResponse response = m_FeatureStoreServiceProxy.EndCheckFeatureState(result); AssertCheckFeatureStateValues(request, response); }
public void ProxyCanCallCheckFeatureStateAsynchronouslyWithPolling() { const string messageId = "ProxyCanCallCheckFeatureStateAsynchronouslyWithPolling"; CheckFeatureStateRequest request = BuildCheckFeatureStateRequestWithSavedFeature(messageId); IAsyncResult result = m_FeatureStoreServiceProxy.BeginCheckFeatureState(request, null, null); while (!result.IsCompleted) { } CheckFeatureStateResponse response = m_FeatureStoreServiceProxy.EndCheckFeatureState(result); AssertCheckFeatureStateValues(request, response); }
/// <summary> /// Builds the check feature state results rich text. /// </summary> /// <param name = "request">The request.</param> /// <param name = "response">The response.</param> /// <param name = "commandName">Name of the command.</param> /// <returns></returns> protected static string BuildResultsRichText(CheckFeatureStateRequest request, CheckFeatureStateResponse 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()); }
public void Execute(IServiceMethodUiBridge serviceMethodUiBridge) { FeatureKey featureKey = BuildFeatureKey(serviceMethodUiBridge); try { CheckFeatureStateRequest request = CheckFeatureStateRequest.Create( MessageIdFactory.GenerateMessageId(), featureKey); IFeatureStoreServiceProxy featureStoreServiceProxy = new FeatureStoreServiceProxy(); CheckFeatureStateResponse response = featureStoreServiceProxy.CheckFeatureState(request); serviceMethodUiBridge.DisplayResults(BuildResultsRichText(request, response, GetType().Name)); } catch (Exception e) { serviceMethodUiBridge.DisplayResults(BuildExceptionRichText(e)); } }
/// <summary> /// Checks the state of an existing Feature. /// </summary> /// <param name = "request"><see cref = "CheckFeatureStateRequest" /> instance that defines the criteria by which the Feature will be queried.</param> /// <returns> /// <see cref = "CheckFeatureStateResponse" /> containing the results of the request for the state of a Feature. /// </returns> public CheckFeatureStateResponse CheckFeatureState(CheckFeatureStateRequest request) { CheckFeatureStateResponse response; try { response = m_FeatureStoreImp.CheckFeatureState(request); } catch (CheckFeatureStateException e) { throw new FaultException <FeatureStoreFault>( FeatureStoreFault.Create(e.Message), new FaultReason( new FaultReasonText( e.Message, CultureInfo.CurrentCulture))); } return(response); }
public void ProxyCanCallCheckFeatureStateAsynchronouslyWithCallback() { const string messageId = "ProxyCanCallCheckFeatureStateAsynchronouslyWithPolling"; ManualResetEvent resetEvent = new ManualResetEvent(false); CheckFeatureStateRequest request = BuildCheckFeatureStateRequestWithSavedFeature(messageId); CheckFeatureStateResponse response = null; m_FeatureStoreServiceProxy.BeginCheckFeatureState( request, r => { response = m_FeatureStoreServiceProxy.EndCheckFeatureState(r); resetEvent.Set(); }, null); resetEvent.WaitOne(); AssertCheckFeatureStateValues(request, response); }
public void NonExistentFeatureResultsInNullResult() { string messageId = Guid.NewGuid().ToString(); FeatureKey query = FeatureKey.Create(-1, Guid.Empty, Guid.Empty); CheckFeatureStateRequest request = CheckFeatureStateRequest.Create(messageId, query); StandardFeatureStore standardFeatureStore = new StandardFeatureStore(m_StorageContainer); using (m_MockRepository.Record()) { Expect.Call(m_StorageContainer.Retrieve(query)).Return(null); m_MockRepository.ReplayAll(); CheckFeatureStateResponse response = standardFeatureStore.CheckFeatureState(request); Assert.AreEqual(messageId, response.Header.MessageId); Assert.IsNull(response.Result); m_MockRepository.VerifyAll(); } }
/// <summary> /// Thread routine that calls the various service methods thus generating the performance counter data. /// </summary> /// <param name="stopper"> /// The stopper. /// </param> private void Runner(object stopper) { ManualResetEvent stopEvent = (ManualResetEvent)stopper; IFeatureStoreServiceProxy proxy = new FeatureStoreServiceProxy(); Action <int>[] calls = new Action <int>[] { v => proxy.CreateFeature(CreateFeatureRequest.Create( "CreateFeature lambda", Feature.Create(1, Guid.NewGuid(), Guid.NewGuid(), Thread.CurrentThread.ManagedThreadId.ToString()))), v => proxy.UpdateFeatureState( UpdateFeatureStateRequest.Create( "UpdateFeatureState lambda", CreateFeatureKey(v), !m_StandardFeatures[v].Enabled)), v => proxy.CheckFeatureState( CheckFeatureStateRequest.Create( "CheckFeatureState lambda", CreateFeatureKey(v))), v => proxy.RetrieveDefinedFeatures( RetrieveDefinedFeaturesRequest.Create( "RetrieveDefinedFeatures lambda", FeatureScope.Create(m_StandardFeatures[v].OwnerId, m_StandardFeatures[v].Space))) }; while (true) { int index = m_Random.Next(0, calls.Length); Console.WriteLine(@"Invoking lambda {0}", index); calls[index].Invoke(index); if (stopEvent.WaitOne(20)) { break; } } }
public void Execute(IServiceMethodUiBridge serviceMethodUiBridge) { m_ServiceMethodUiBridge = serviceMethodUiBridge; AsyncOperation asyncOperation = AsyncOperationManager.CreateOperation(m_AsyncKey); FeatureKey featureKey = BuildFeatureKey(serviceMethodUiBridge); try { CheckFeatureStateRequest request = CheckFeatureStateRequest.Create( MessageIdFactory.GenerateMessageId(), featureKey); IFeatureStoreServiceProxy featureStoreServiceProxy = new FeatureStoreServiceProxy(); featureStoreServiceProxy.BeginCheckFeatureState( request, ar => { string rtfResults; try { CheckFeatureStateResponse response = featureStoreServiceProxy.EndCheckFeatureState(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 QueryExistingFeature() { string messageId = Guid.NewGuid().ToString(); Guid space = Guid.NewGuid(); Guid owner = Guid.NewGuid(); FeatureKey query = FeatureKey.Create(1, owner, space); CheckFeatureStateRequest request = CheckFeatureStateRequest.Create(messageId, query); Feature foundFeature = Feature.Create(1, owner, space, FeatureName); StandardFeatureStore standardFeatureStore = new StandardFeatureStore(m_StorageContainer); using (m_MockRepository.Record()) { Expect.Call(m_StorageContainer.Retrieve(query)).Return(foundFeature); m_MockRepository.ReplayAll(); CheckFeatureStateResponse response = standardFeatureStore.CheckFeatureState(request); Assert.AreEqual(messageId, response.Header.MessageId); Assert.IsNotNull(response); Assert.IsFalse(response.Result.Enabled); m_MockRepository.VerifyAll(); } }
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"); }
/// <summary> /// Checks the state of an existing Feature. /// </summary> /// <param name = "request"><see cref = "CheckFeatureStateResponse" /> instance that defines the criteria by which the Feature will be queried.</param> /// <returns> /// <see cref = "CheckFeatureStateRequest" /> containing the results of the request for the state of a Feature. /// </returns> public CheckFeatureStateResponse CheckFeatureState(CheckFeatureStateRequest request) { return(Channel.CheckFeatureState(request)); }
/// <summary> /// Begins the state of the check feature. /// </summary> /// <param name = "request">The request.</param> /// <param name = "callback">The async callback.</param> /// <param name = "state">The state.</param> /// <returns> /// <see cref = "IAsyncResult" /> instance used to query the state of the asynchronous operation. /// </returns> public IAsyncResult BeginCheckFeatureState( CheckFeatureStateRequest request, AsyncCallback callback, object state) { return(Channel.BeginCheckFeatureState(request, callback, state)); }