public void MeldKeuringMetSteekproef()
        {
            // Arrange
            var mockPublisher = new Mock <IEventPublisher>(MockBehavior.Strict);

            mockPublisher.Setup(publisher => publisher.Publish(It.IsAny <KeuringVerwerktMetSteekproefEvent>()));

            KeuringsVerzoekCommand keuringsVerzoekCommand = DefaultKeuringsVerzoekCommand();
            string responseXml = File.ReadAllText("XMLTestFiles/KeuringsRegistratieMetSteefproef.xml");

            var mockContext = new Mock <LogContext>();

            mockContext.Setup(context => context.Logs.Add(It.IsAny <Log>()));
            mockContext.Setup(context => context.SaveChanges());

            var mockRDWAgent = new Mock <IRDWAgent>(MockBehavior.Strict);

            mockRDWAgent.Setup(rdwAgent => rdwAgent.SendKeuringsVerzoekAsync(It.IsAny <string>()))
            .ReturnsAsync(responseXml);

            var target = new KeuringController(mockContext.Object, mockPublisher.Object, mockRDWAgent.Object);

            // Act
            var result = target.Verzoek(keuringsVerzoekCommand).Result;

            //Assert
            Assert.IsInstanceOfType(result, typeof(OkResult));
            mockPublisher.Verify(publisher => publisher.Publish(It.Is <KeuringVerwerktMetSteekproefEvent>(e =>
                                                                                                          e.OnderhoudsGuid == Guid.ParseExact("c4ab88e8-b266-4816-a174-d4cf26b3832b", "D")))
                                 , Times.Once);

            mockContext.Verify(context => context.Logs.Add(It.IsAny <Log>()), Times.Exactly(2));
            mockContext.Verify(context => context.SaveChanges(), Times.Once);
        }
        public void BadRequestKeuringverzoek()
        {
            var mockPublisher = new Mock <IEventPublisher>(MockBehavior.Strict);

            KeuringsVerzoekCommand keuringsVerzoekCommand = DefaultKeuringsVerzoekCommand();

            var mockContext = new Mock <LogContext>();

            var mockRDWAgent = new Mock <IRDWAgent>(MockBehavior.Strict);

            mockRDWAgent.Setup(rdwAgent => rdwAgent.SendKeuringsVerzoekAsync(It.IsAny <string>()))
            .Throws <AggregateException>();

            var target = new KeuringController(mockContext.Object, mockPublisher.Object, mockRDWAgent.Object);

            // Act
            var result = target.Verzoek(keuringsVerzoekCommand).Result;

            //Assert
            Assert.IsInstanceOfType(result, typeof(BadRequestResult));
            mockContext.Verify(context => context.Logs.Add(It.IsAny <Log>()), Times.Never);
        }
예제 #3
0
        public IActionResult KeuringsVerzoek(KeuringsVerzoekCommand domainCommand)
        {
            // Simulate an incoming event
            OnderhoudDispatcher dispatcher = new OnderhoudDispatcher(_context);

            Random random = new Random();

            if (random.Next(0, 2) == 0)
            {
                KeuringVerwerktMetSteekproefEvent domainEvent = new KeuringVerwerktMetSteekproefEvent();
                domainEvent.OnderhoudsGuid = Guid.NewGuid();
                dispatcher.KeuringsVerzoekVerwerktMetSteekproef(domainEvent);
            }
            else
            {
                KeuringVerwerktZonderSteekproefEvent domainEvent = new KeuringVerwerktZonderSteekproefEvent();
                domainEvent.OnderhoudsGuid = Guid.NewGuid();
                dispatcher.KeuringsVerzoekVerwerktZonderSteekproef(domainEvent);
            }

            return(new OkResult());
        }
예제 #4
0
        public async Task <IActionResult> Verzoek([FromBody] KeuringsVerzoekCommand keuringsVerzoekCommand)
        {
            var verzoek = new keuringsverzoek()
            {
                keuringsdatum = DateTime.Now,
                voertuig      = new keuringsverzoekVoertuig()
                {
                    kenteken       = keuringsVerzoekCommand.Kenteken,
                    kilometerstand = keuringsVerzoekCommand.Kilometerstand,
                    naam           = keuringsVerzoekCommand.Klantnaam
                }
            };

            string response;

            try
            {
                string verzoekXml = SerializeKeuringsverzoekToXml(verzoek);
                response = await _RDWAgent.SendKeuringsVerzoekAsync(verzoekXml);

                var keuringsregistratie = SerializeToKeuringsregistratie(response);

                bool isSteekproef = keuringsregistratie.steekproef != null;

                _logContext.Logs.Add(new Log()
                {
                    Xml  = verzoekXml,
                    Type = typeof(keuringsverzoek).ToString()
                });

                _logContext.Logs.Add(new Log()
                {
                    Xml  = response,
                    Type = typeof(keuringsregistratie).ToString()
                });
                _logContext.SaveChanges();

                if (!isSteekproef)
                {
                    _publisher.Publish(new KeuringVerwerktZonderSteekproefEvent()
                    {
                        OnderhoudsGuid = keuringsVerzoekCommand.OnderhoudsGuid,
                        Keuringsdatum  = keuringsregistratie.keuringsdatum
                    });
                }
                else if (isSteekproef)
                {
                    _publisher.Publish(new KeuringVerwerktMetSteekproefEvent()
                    {
                        OnderhoudsGuid  = keuringsVerzoekCommand.OnderhoudsGuid,
                        SteefproefDatum = (DateTime)keuringsregistratie.steekproef,
                        Keuringsdatum   = keuringsregistratie.keuringsdatum
                    });
                }
            }
            catch (AggregateException exception)
            {
                return(BadRequest());
            }

            return(Ok());
        }