예제 #1
0
        public async Task UpdatePreferenceKeyExecutor_MissingKeyUID()
        {
            const string keyName = "some key";
            var          keyUid  = Guid.NewGuid();

            var prefKeyDatabase = new PrefKeyDataModel
            {
                KeyName          = keyName,
                PreferenceKeyUID = keyUid.ToString(),
                PreferenceKeyID  = 12345
            };

            mockPrefRepo.Setup(p => p.GetPreferenceKey(null, keyName))
            .ReturnsAsync((PrefKeyDataModel)null);

            var prefEvent = new UpdatePreferenceKeyEvent
            {
                PreferenceKeyName = "some other key",
                PreferenceKeyUID  = keyUid
            };

            mockPrefRepo.Setup(p => p.StoreEvent(prefEvent))
            .ReturnsAsync(0);

            var executor = RequestExecutorContainerFactory.Build <UpdatePreferenceKeyExecutor>
                               (Logger, ServiceExceptionHandler, mockPrefRepo.Object);
            var ex = await Assert.ThrowsAsync <ServiceException>(async() => await executor.ProcessAsync(prefEvent));

            Assert.Equal(HttpStatusCode.InternalServerError, ex.Code);
            var result = ex.GetResult;

            Assert.Equal(2003, result.Code);
            Assert.Equal("Unable to update preference key. ", result.Message);
        }
예제 #2
0
        public async Task UpdatePreferenceKeyExecutor_DuplicateKeyName()
        {
            const string keyName = "some key";

            var prefKeyDatabase = new PrefKeyDataModel
            {
                KeyName          = keyName,
                PreferenceKeyUID = Guid.NewGuid().ToString(),
                PreferenceKeyID  = 12345
            };

            mockPrefRepo.Setup(p => p.GetPreferenceKey(null, keyName))
            .ReturnsAsync(prefKeyDatabase);

            var prefEvent = new UpdatePreferenceKeyEvent
            {
                PreferenceKeyName = keyName,
                PreferenceKeyUID  = Guid.NewGuid()
            };

            var executor = RequestExecutorContainerFactory.Build <UpdatePreferenceKeyExecutor>
                               (Logger, ServiceExceptionHandler, mockPrefRepo.Object);
            var ex = await Assert.ThrowsAsync <ServiceException>(async() => await executor.ProcessAsync(prefEvent));

            Assert.Equal(HttpStatusCode.BadRequest, ex.Code);
            var result = ex.GetResult;

            Assert.Equal(2004, result.Code);
            Assert.Equal($"Duplicate preference key name. {keyName}", result.Message);
        }
예제 #3
0
        public void MapPrefKeyDatabaseModelToResult()
        {
            var prefKey = new PrefKeyDataModel
            {
                KeyName          = "some preference key",
                PreferenceKeyUID = Guid.NewGuid().ToString(),
            };

            var result = AutoMapperUtility.Automapper.Map <PreferenceKeyV1Result>(prefKey);

            Assert.Equal(prefKey.KeyName, result.PreferenceKeyName);
            Assert.Equal(prefKey.PreferenceKeyUID, result.PreferenceKeyUID.ToString());
            Assert.Equal(ContractExecutionStatesEnum.ExecutedSuccessfully, result.Code);
            Assert.Equal(ContractExecutionResult.DefaultMessage, result.Message);
        }
예제 #4
0
        public async Task CreatePreferenceKeyExecutor_HappyPath()
        {
            const string keyName = "some key";
            var          keyUid  = Guid.NewGuid();

            mockPrefRepo.Setup(p => p.GetPreferenceKey(null, keyName))
            .ReturnsAsync((PrefKeyDataModel)null);
            mockPrefRepo.Setup(p => p.GetPreferenceKey(keyUid, null))
            .ReturnsAsync((PrefKeyDataModel)null);

            var prefEvent = new CreatePreferenceKeyEvent
            {
                PreferenceKeyName = keyName,
                PreferenceKeyUID  = keyUid
            };

            mockPrefRepo.Setup(p => p.StoreEvent(prefEvent))
            .ReturnsAsync(1);
            var prefKeyDatabase = new PrefKeyDataModel
            {
                KeyName          = keyName,
                PreferenceKeyUID = keyUid.ToString(),
                PreferenceKeyID  = 12345
            };

            mockPrefRepo.Setup(p => p.GetPreferenceKey(keyUid, keyName))
            .ReturnsAsync(prefKeyDatabase);

            var executor = RequestExecutorContainerFactory.Build <CreatePreferenceKeyExecutor>
                               (Logger, ServiceExceptionHandler, mockPrefRepo.Object);
            var result = await executor.ProcessAsync(prefEvent) as PreferenceKeyV1Result;

            Assert.Equal(ContractExecutionStatesEnum.ExecutedSuccessfully, result.Code);
            Assert.Equal(ContractExecutionResult.DefaultMessage, result.Message);
            Assert.Equal(prefEvent.PreferenceKeyName, result.PreferenceKeyName);
            Assert.Equal(prefEvent.PreferenceKeyUID, result.PreferenceKeyUID);
        }