Esempio n. 1
0
        public void Calculate_SuccessfulCalculation_WaternetSet(bool messagesNull)
        {
            // Setup
            const string name = "Waternet";

            var output = new WaternetCreatorOutput
            {
                Waternet = new CSharpWrapperWaternet(),
                Messages = messagesNull ? null : new Message[0]
            };

            var mocks      = new MockRepository();
            var calculator = mocks.Stub <ICalculator>();

            calculator.Stub(c => c.CalculateWaternet(0)).Return(output);
            var validator = mocks.Stub <IValidator>();

            validator.Stub(v => v.ValidateWaternetCreator()).Return(new ValidationOutput
            {
                IsValid = true
            });
            mocks.ReplayAll();

            var kernel = new WaternetKernelWrapper(calculator, validator, name);

            // Call
            kernel.Calculate();

            // Assert
            Assert.AreSame(output.Waternet, kernel.Waternet);
            Assert.AreEqual(name, kernel.Waternet.Name);
            mocks.VerifyAll();
        }
Esempio n. 2
0
        public void Calculate_ErrorMessageInCalculationOutput_ThrowsWaternetKernelWrapperException()
        {
            // Setup
            const string message1 = "Message1";
            const string message2 = "Message2";
            const string message3 = "Message3";

            var waternetCreatorOutput = new WaternetCreatorOutput
            {
                Messages = new List <Message>
                {
                    new Message
                    {
                        Content     = message1,
                        MessageType = MessageType.Error
                    },
                    new Message
                    {
                        Content     = message2,
                        MessageType = MessageType.Error
                    },
                    new Message
                    {
                        Content     = message3,
                        MessageType = MessageType.Warning
                    }
                },
                Waternet = new CSharpWrapperWaternet()
            };

            var mocks      = new MockRepository();
            var calculator = mocks.Stub <ICalculator>();

            calculator.Stub(c => c.CalculateWaternet(0)).Return(waternetCreatorOutput);
            var validator = mocks.Stub <IValidator>();

            validator.Stub(v => v.ValidateWaternetCreator()).Return(new ValidationOutput
            {
                IsValid = true
            });
            mocks.ReplayAll();

            var kernel = new WaternetKernelWrapper(calculator, validator, string.Empty);

            // Call
            void Call() => kernel.Calculate();

            // Assert
            var    exception       = Assert.Throws <WaternetKernelWrapperException>(Call);
            string expectedMessage = $"{message1}{Environment.NewLine}" +
                                     $"{message2}";

            Assert.AreEqual(expectedMessage, exception.Message);
            mocks.VerifyAll();
        }
Esempio n. 3
0
        public void Calculate()
        {
            try
            {
                CheckIfWaternetCanBeGenerated();

                WaternetCreatorOutput output = calculator.CalculateWaternet(0);

                Waternet      = output.Waternet;
                Waternet.Name = waternetName;

                ReadLogMessages(output.Messages ?? Enumerable.Empty <Message>());
            }
            catch (Exception e) when(!(e is WaternetKernelWrapperException))
            {
                throw new WaternetKernelWrapperException(e.Message, e);
            }
        }