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(); } }
public void CreateFeatureThrowsFeatureStoreFaultExceptionOnException() { IStorageContainer storageContainer = m_MockRepository.StrictMock <IStorageContainer>(); Feature feature = Feature.Create(1, Guid.NewGuid(), Guid.NewGuid(), "CreateFeatureThrowsCreateFeatureFaultOnException"); using (m_MockRepository.Record()) { Expect.Call(storageContainer.Retrieve(FeatureKey.Create(feature.Id, feature.OwnerId, feature.Space))). Throw(new CreateFeatureException("Bad Mojo Exception")); m_MockRepository.ReplayAll(); FeatureStoreService featureStoreService = new FeatureStoreService(storageContainer); try { featureStoreService.CreateFeature( CreateFeatureRequest.Create( "CreateFeatureThrowsCreateFeatureFaultOnException", feature)); Assert.Fail("Expecting FaultException<FeatureStoreFault>"); } catch (FaultException <FeatureStoreFault> e) { Console.WriteLine(e.Detail.Message); Console.WriteLine(e.Message); StringAssert.Contains(e.Detail.Message, "Bad Mojo Exception"); } m_MockRepository.VerifyAll(); } }
private static FeatureKey BuildFeatureKey(string line) { string[] parts = line.Split(' '); return(FeatureKey.Create( long.Parse(parts[0]), new Guid(parts[2]), new Guid(parts[1]))); }
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 UpdateFeatureStateExceptionThrownWhenUpdatingNonExistentFeature() { string messageId = Guid.NewGuid().ToString(); Guid space = Guid.NewGuid(); Guid owner = Guid.NewGuid(); FeatureKey featureQuery = FeatureKey.Create(1, owner, space); StandardFeatureStore standardFeatureStore = new StandardFeatureStore(m_StorageContainer); UpdateFeatureStateRequest request = UpdateFeatureStateRequest.Create(messageId, featureQuery, true); using (m_MockRepository.Record()) { Expect.Call(m_StorageContainer.Retrieve(featureQuery)).Return(null); m_MockRepository.ReplayAll(); try { standardFeatureStore.UpdateFeatureState(request); Assert.Fail("Expected a UpdateFeatureStateException to be thrown"); } catch (UpdateFeatureStateException ex) { StringAssert.Contains(ex.Message, "Id 1"); StringAssert.Contains(ex.Message, "Space " + space); Assert.IsNotNull(ex.InnerException); } } }
public void CreateFeatureExceptionThrownWhenCreationFails() { string messageId = Guid.NewGuid().ToString(); Exception exception = m_MockRepository.StrictMock <Exception>(); Feature toCreate = Feature.Create(1, Guid.NewGuid(), Guid.NewGuid(), FeatureName); CreateFeatureRequest request = CreateFeatureRequest.Create(messageId, toCreate); IFeatureStore featureStore = new StandardFeatureStore(m_StorageContainer); using (m_MockRepository.Record()) { Expect.Call(exception.Message).Return("Bad Mojo"); Expect.Call(m_StorageContainer.Retrieve(FeatureKey.Create(toCreate.Id, toCreate.OwnerId, toCreate.Space))) .Return(null); Expect.Call(m_StorageContainer.Store(toCreate)).Throw(exception); m_MockRepository.ReplayAll(); try { featureStore.CreateFeature(request); Assert.Fail("Expected FeatureCreationException"); } catch (CreateFeatureException) { } m_MockRepository.VerifyAll(); } }
public void CreateFeatureFailsWhenDuplicateKeyProvided() { string messageId = Guid.NewGuid().ToString(); Feature toCreate = Feature.Create(1, Guid.NewGuid(), Guid.NewGuid(), FeatureName); IFeatureStore featureStore = new StandardFeatureStore(m_StorageContainer); using (m_MockRepository.Record()) { Expect.Call(m_StorageContainer.Retrieve(FeatureKey.Create(toCreate.Id, toCreate.OwnerId, toCreate.Space))) .Return(toCreate); m_MockRepository.ReplayAll(); try { featureStore.CreateFeature(CreateFeatureRequest.Create(messageId, toCreate)); Assert.Fail("Expected FeatureCreationException due to duplicate key violation."); } catch (CreateFeatureException e) { StringAssert.Contains(e.Message, "duplicate key violation"); StringAssert.Contains(e.Message, "Id"); StringAssert.Contains(e.Message, "OwnerId"); StringAssert.Contains(e.Message, "Space"); } } }
public void CreateFeature() { Feature toCreate = Feature.Create(1, Guid.NewGuid(), Guid.NewGuid(), FeatureName); IStorageContainer container = m_MockRepository.StrictMock <IStorageContainer>(); string messageId = Guid.NewGuid().ToString(); using (m_MockRepository.Record()) { Expect.Call(container.Retrieve(FeatureKey.Create(toCreate.Id, toCreate.OwnerId, toCreate.Space))).Return (null); Expect.Call(container.Store(toCreate)).Return(toCreate); m_MockRepository.ReplayAll(); StandardFeatureStore service = new StandardFeatureStore(container); CreateFeatureRequest request = CreateFeatureRequest.Create(messageId, toCreate); CreateFeatureResponse response = service.CreateFeature(request); Assert.AreEqual(messageId, response.Header.MessageId); Assert.AreEqual(toCreate.Id, response.Result.Id); Assert.AreEqual(toCreate.Name, response.Result.Name); Assert.AreEqual(toCreate.Space, response.Result.Space); Assert.AreEqual(toCreate.OwnerId, response.Result.OwnerId); m_MockRepository.VerifyAll(); } }
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(); } }
/// <summary> /// Builds the feature key. /// </summary> /// <param name = "serviceMethodUiBridge">The service method UI bridge.</param> /// <returns></returns> protected FeatureKey BuildFeatureKey(IServiceMethodUiBridge serviceMethodUiBridge) { return(FeatureKey.Create( serviceMethodUiBridge.FeatureStoreMethodArguments.Id, serviceMethodUiBridge.FeatureStoreMethodArguments.OwnerId, serviceMethodUiBridge.FeatureStoreMethodArguments.Space)); }
/// <summary> /// Stores the specified entity. /// </summary> /// <param name = "feature">The entity to be stored.</param> /// <returns>The entity that was saved.</returns> public Feature Store(Feature feature) { FeatureKey featureKey = FeatureKey.Create(feature.Id, feature.OwnerId, feature.Space); m_FeatureList.AddOrUpdate(featureKey, key => feature, (key, original) => feature); return(feature); }
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 UpdateFeatureStateRequest BuildUpdateFeatureStateRequestWithSavedFeature(string messageId) { Feature feature = Feature.Create(2, Guid.NewGuid(), Guid.NewGuid(), "UpdateFeatureStateFeature"); AddFeatureToStorage(messageId, feature); return(UpdateFeatureStateRequest.Create( messageId, FeatureKey.Create(feature.Id, feature.OwnerId, feature.Space), !feature.Enabled)); }
/// <summary> /// Checks the duplicate key. /// </summary> /// <param name = "feature">The feature.</param> private void CheckDuplicateKey(Feature feature) { if (m_StorageContainer.Retrieve(FeatureKey.Create(feature.Id, feature.OwnerId, feature.Space)) != null) { throw new CreateFeatureException( string.Format( CultureInfo.CurrentUICulture, ExceptionMessageResources.DUPLICATE_KEY_VIOLATION, feature.Id, feature.OwnerId, feature.Space)); } }
public void ExistingFeatureStorageFileIsLoaded() { CacheSwappingStorageContainer container = new CacheSwappingStorageContainer(@"features.dat"); Feature feature = container.Retrieve( FeatureKey.Create( 5, new Guid("a7fd39ea-95a1-48d3-9c5e-0aee8045f3f7"), new Guid("275f5020-b4ec-4f6c-90d7-798999c8d932"))); Assert.IsNotNull(feature); Assert.AreEqual("Feature 5", feature.Name); Assert.IsFalse(feature.Enabled); }
private void BuildFeatureStore() { Console.WriteLine(string.Format(CultureInfo.CurrentUICulture, @">. Building {0} Features.", m_FeatureCount)); using (new InternalStopWatch("BuildFeatureStore")) { m_Dictionary = new ConcurrentDictionary <FeatureKey, Feature>(); for (int index = 0; index < m_FeatureCount; index++) { Guid space = Guid.NewGuid(); Guid owner = Guid.NewGuid(); m_Dictionary.AddOrUpdate(FeatureKey.Create(index, owner, space), Feature.Create(index, owner, space, "Feature " + index), (k, f) => f); } } }
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(); } }
public void UpdateFeature() { Feature feature = Feature.Create(2112, Guid.NewGuid(), Guid.NewGuid(), "To Be Updated"); Feature stored = m_StorageContainer.Store(feature); Assert.IsFalse(feature.Enabled); Assert.IsFalse(stored.Enabled); stored.Enabled = true; Feature newStored = m_StorageContainer.Store(stored); Assert.IsNotNull(newStored); Assert.IsTrue(newStored.Enabled); Feature retrieved = m_StorageContainer.Retrieve(FeatureKey.Create(stored.Id, stored.OwnerId, stored.Space)); Assert.IsNotNull(retrieved); Assert.IsTrue(retrieved.Enabled); }
/// <summary> /// Stores the specified entity. /// </summary> /// <param name = "feature">The entity to be stored.</param> /// <returns>The entity that was saved.</returns> public Feature Store(Feature feature) { lock (m_SyncRoot) { FeatureKey featureKey = FeatureKey.Create(feature.Id, feature.OwnerId, feature.Space); // update the current backup copy m_BackupFeatureList.AddOrUpdate(featureKey, key => feature, (key, original) => feature); // persist the new feature set to disk SerializeCache(m_BackupFeatureList); // swap the backup into the active m_BackupFeatureList = Interlocked.Exchange(ref m_ActiveFeatureList, m_BackupFeatureList); // update the previously active copy m_BackupFeatureList.AddOrUpdate(featureKey, key => feature, (key, original) => feature); } return(feature); }
public void MultipleFeaturesCanBeAddedToStorageAndQueriedIndividually() { const string featureNameBase = "Feature Name "; const int count = 5; Guid[] spaces = new Guid[count]; Guid[] owners = new Guid[count]; for (int index = 0; index < count; index++) { spaces[index] = Guid.NewGuid(); owners[index] = Guid.NewGuid(); Feature feature = Feature.Create(index, owners[index], spaces[index], featureNameBase + index); Feature stored = m_StorageContainer.Store(feature); Assert.AreEqual(feature.Id, stored.Id); Assert.AreEqual(feature.Space, stored.Space); Assert.AreEqual(feature.OwnerId, stored.OwnerId); Assert.AreEqual(feature.Name, stored.Name); Assert.IsFalse(stored.Enabled); } for (int index = 0; index < 5; index++) { Feature retrieved = m_StorageContainer.Retrieve(FeatureKey.Create(index, owners[index], spaces[index])); Assert.IsNotNull(retrieved); Assert.AreEqual(index, retrieved.Id); Assert.AreEqual(spaces[index], retrieved.Space); Assert.AreEqual(owners[index], retrieved.OwnerId); Assert.AreEqual(featureNameBase + index, retrieved.Name); Assert.IsFalse(retrieved.Enabled); } Assert.IsNull(m_StorageContainer.Retrieve(FeatureKey.Create(2112, Guid.Empty, Guid.Empty))); }
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(); } }
/// <summary> /// Generates a <see cref="FeatureKey"/> from the <see cref="Feature"/> at the given index. /// </summary> /// <param name="index"> /// The index. /// </param> /// <returns> /// An initialized <see cref="FeatureKey"/>. /// </returns> private FeatureKey CreateFeatureKey(int index) { Feature feature = m_StandardFeatures[index]; return(FeatureKey.Create(feature.Id, feature.OwnerId, feature.Space)); }
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"); }