public void CalculateNewValueTest()
        {
            // Arrange.
            var fileValue = Mock.Create<IFileProcess>();
            var updater = new FileFieldUpdater { ValueCalculator = (s, d) => fileValue };

            // Act.
            updater.CalculateNewValue(new DataTriggerSourceData(), Mock.Create<IEditableRoot>());

            // Assert.
            Assert.AreSame(fileValue, updater.NewValue);

            // Arrange.
            updater.ValueCalculator = (s, d) => "Invalid";

            // Act / Assert.
            TestsHelper.VerifyThrow<InvalidOperationException>(() => updater.CalculateNewValue(new DataTriggerSourceData(), Mock.Create<IEditableRoot>()));
        }
        public void InitializeTest()
        {
            // Arrange.
            const string ProcessName = "TestProcess";

            var dtm = Mock.Create<IDynamicTypeManager>();
            Mock.Arrange(() => dtm.GetEditableRootType(ProcessName)).Returns(typeof(TestEdit));

            var mapping = new DataTriggerFieldMapping(TestsHelper.ExtractPropertyName(() => new TestEdit().File), false, (s, d) => null);
            
            var updater = new FileFieldUpdater { DynamicTypeManager = dtm };

            // Act.
            updater.Initialize(ProcessName, mapping);

            // Assert.
            Assert.AreEqual(TestsHelper.ExtractPropertyName(() => new TestEdit().File), updater.FieldName);
            Assert.AreSame(mapping.ValueCalculator, updater.ValueCalculator);
        }
        public void UpdateTest()
        {
            // Arrange.
            const string TempDocumentUnc = @"d:\Files\Temp";
            const string FileProcessorUri = "http://localhost/FileProcessor";
            const string SourceFileName = "448E2A97-A4A5-4BC9-94D8-584970958239.txt";
            const string OriginalFileName = "test.txt";

            var systemOptions = Mock.Create<ISystemOptionsInfo>();
            Mock.Arrange(() => systemOptions.TempDocumentUNC).Returns(TempDocumentUnc);
            Mock.Arrange(() => systemOptions.FileProcessorURI).Returns(FileProcessorUri);

            var systemOptionsRetriever = Mock.Create<ISystemOptionsInfoRetriever>();
            Mock.Arrange(() => systemOptionsRetriever.GetSystemOptions()).Returns(systemOptions);

            var sourceFile = Mock.Create<IFileProcess>();
            Mock.Arrange(() => sourceFile.FileName).Returns(SourceFileName);
            Mock.Arrange(() => sourceFile.OriginalFileName).Returns(OriginalFileName);

            var destinationFile = Mock.Create<IFileProcess>();

            var destination = new TestEdit { File = destinationFile };

            var webRequest = Mock.Create<HttpWebRequest>();
            Mock.Arrange(() => WebRequest.Create(Arg.IsAny<Uri>())).Returns(webRequest);

            var webResponse = Mock.Create<HttpWebResponse>();
            Mock.Arrange(() => webRequest.GetResponse()).Returns(webResponse);
            
            var responseStream = Mock.Create<Stream>();
            Mock.Arrange(() => webResponse.GetResponseStream()).Returns(responseStream);

            var outputStream = Mock.Create<FileStream>();
            Mock.Arrange(() => File.OpenWrite(Arg.IsAny<string>())).Returns(outputStream);

            Mock.Arrange(() => destinationFile.UploadFile()).DoNothing();

            var updater = new FileFieldUpdater { SystemOptionsRetriever = systemOptionsRetriever, NewValue = sourceFile, FieldName = TestsHelper.ExtractPropertyName(() => new TestEdit().File) };

            // Act.
            updater.Update(destination);

            // Assert.
            Assert.IsFalse(string.IsNullOrEmpty(destinationFile.FileName));
            Assert.AreEqual(OriginalFileName, destinationFile.OriginalFileName);

            Mock.Assert(() => File.OpenWrite(Path.Combine(TempDocumentUnc, destinationFile.FileName)), Occurs.Once());
            Mock.Assert(() => responseStream.CopyTo(outputStream, Arg.IsAny<int>()), Occurs.Once());
            Mock.Assert(() => destinationFile.UploadFile(), Occurs.Once());
        }