コード例 #1
0
ファイル: EntryServiceTest.cs プロジェクト: Kianek/WritelyApi
            public async Task CanDeleteExistingEntry()
            {
                using (var context = new AppDbContext(_options))
                {
                    var service = new EntryService(context);
                    var entry   = new Entry {
                        Title = "Delete Me", Body = "Boring stuff"
                    };
                    var journal =
                        new Journal
                    {
                        Id      = 1,
                        Title   = "My Journal",
                        Entries = new List <Entry>()
                    };

                    journal.Entries.Add(entry);
                    context.Journals.Add(journal);
                    await context.SaveChangesAsync();

                    var result =
                        await service.Delete(new EntryDeletionDto { EntryId = entry.Id, JournalId = journal.Id });

                    result.Should().BeGreaterThan(0, "because more than one object was updated");
                }
            }
コード例 #2
0
        public void TestAddEntryToLog_ShouldCallFactoryCreateLogEntry(string content, int logId)
        {
            // Arrange
            var mockedLogService = new Mock <ILogService>();

            var date = new DateTime();

            var mockedDateTimeProvider = new Mock <IDateTimeProvider>();

            mockedDateTimeProvider.Setup(p => p.GetCurrentTime())
            .Returns(date);

            var mockedFactory    = new Mock <ILogEntryFactory>();
            var mockedRepository = new Mock <IRepository <LogEntry> >();
            var mockedUnitOfWork = new Mock <IUnitOfWork>();

            var service = new EntryService(mockedLogService.Object,
                                           mockedDateTimeProvider.Object,
                                           mockedFactory.Object,
                                           mockedRepository.Object,
                                           mockedUnitOfWork.Object);

            // Act
            service.AddEntryToLog(content, logId, null);

            // Assert
            mockedFactory.Verify(f => f.CreateLogEntry(content, date, logId), Times.Once);
        }
コード例 #3
0
        public EntryServiceTests()
        {
            _mockEntryRepository = new Mock <IEntryRepository>();
            _mockBase64Validator = new Mock <IBase64Validator>();

            _objectToTest = new EntryService(_mockEntryRepository.Object, _mockBase64Validator.Object);
        }
コード例 #4
0
        // GET: Teams/Create
        public ActionResult Create()
        {
            TeamCreateViewModel teamCreateViewModel = new TeamCreateViewModel();
            var entryList = new List <EntryDropDownListViewModel>();

            var mapperConfig = new MapperConfiguration(cfg =>
            {
                cfg.CreateMap <EntryDTO, EntryDropDownListViewModel>();
            });

            using (var entryService = new EntryService())
            {
                try
                {
                    var user        = SessionLoginUtilities.GetLoggedInUser(Session);
                    var allEntryDto = user.Permissions.GetEntryAdminPermissons <EntryDTO>();
                    if (allEntryDto == null)
                    {
                        throw new NullReferenceException();
                    }
                    var mapper = mapperConfig.CreateMapper();
                    mapper.Map(allEntryDto, entryList);

                    ViewBag.EntryDropDownList = new SelectList(entryList.OrderBy(b => b.FullEntryName), "Id", "FullEntryName");

                    return(View());
                }
                catch (Exception e)
                {
                    TempData["ResultMessage"] = e.Message;
                    return(View("Error"));
                }
            }
        }
コード例 #5
0
        public async Task MoveEntryToJournal_JournalFound_EntryMoved()
        {
            // Arrange
            var destJournal = CreateJournal();

            destJournal.Id    = 2L;
            destJournal.Title = "Journal 2";

            var srcJournal = CreateJournal();
            var entry      = CreateEntry();

            entry.Journal   = srcJournal;
            entry.JournalId = srcJournal.Id;
            srcJournal.Entries.Add(entry);

            _context.Journals.AddRange(srcJournal, destJournal);
            await _context.SaveChangesAsync();

            // Act
            var service = new EntryService(_context);
            var result  = await service.MoveEntryToJournal(entry.Id, destJournal.Id);

            // Assert
            result.JournalId.Should().Be(destJournal.Id);
        }
コード例 #6
0
        public ActionResult Create(PocoClasses.Entries.Team newTeam, int entryId)
        {
            Mapper.Initialize(cfg => cfg.CreateMap <PocoClasses.Entries.Team, Team>());
            Team team = Mapper.Map <Team>(newTeam);

            team.EntryId = entryId;

            if (ModelState.IsValid)
            {
                using (var context = new TeamContext())
                {
                    var service = new TeamService(context);
                    service.Add(team);
                }
                using (var context = new RaceEntryContext())
                {
                    var service = new RaceEntryService(context);
                    service.Add(team.Id, newTeam.EventId);
                }

                Entry entry;
                using (var context = new EntryContext())
                {
                    var service = new EntryService(new RosContext <Entry>());
                    entry = service.GetById(entryId);
                }
                return(RedirectToAction("Index", entry));
            }
            return(View(team));
        }
コード例 #7
0
        public static void RemoveExistingEntryById()
        {
            Console.Clear();

            var entries = _repository.GetAll().ToList();

            if (entries.Count() == 0)
            {
                Console.WriteLine("There are no entries available");
            }
            else
            {
                foreach (var item in entries)
                {
                    DisplayEntryColorBasedOnType(item);
                }

                Console.ResetColor();
                Console.WriteLine();
                Console.WriteLine("Please type id of entry to remove: ");
                int id;
                while (!int.TryParse(Console.ReadLine(), out id))
                {
                    Console.WriteLine("Please enter valid id:");
                }
                ;

                IEntryService entryService = new EntryService(_repository);
                entryService.RemoveEntryById(id);

                Console.WriteLine(Environment.NewLine + "Entry removed");
            }
            ReturnToMenuMessage();
        }
コード例 #8
0
        public async Task GetAllByJournal_JournalFound_ReturnsEntries()
        {
            // Arrange
            var   journal = CreateJournal();
            Entry entry;

            for (var i = 0; i < 5; i++)
            {
                entry           = CreateEntry();
                entry.Journal   = journal;
                entry.JournalId = journal.Id;
                journal.Entries.Add(entry);
            }

            _context.Journals.Add(journal);
            await _context.SaveChangesAsync();

            // Act
            var service = new EntryService(_context);
            var result  = await service.GetAllByJournal(journal.Id);

            // Assert
            result.Should().NotBeNullOrEmpty();
            result.Should().HaveCount(5);
        }
コード例 #9
0
        public void RegisterMotorcycle_WithoutCC_ShouldReturnException()
        {
            // Arrange (preparación, organizar)
            var      entryBuilder = new EntryDTOBuilder();
            DtoEntry entry        = entryBuilder
                                    .WithCC(null)
                                    .Build();

            // cuando se ejecute este método en el entry service va a retornar true en la validacion de ExistsQuotaByVehicleType
            _cellService.Setup(cs => cs.ExistsQuotaByVehicleType(VehicleTypeEnum.motorcycle)).Returns(true);
            _placaService.Setup(ps => ps.GetLastNumberOfIdVehicle(entry.IdVehicleType, entry.IdVehicle)).Returns("5");

            var entryService = new EntryService(entryRepository.Object, _cellService.Object, _departureService.Object, _placaService.Object);


            // Act
            try
            {
                entryService.RegistryVehicle(entry);
            }
            catch (Exception e)
            {
                var message = "Falta la información del cilindraje de la motocicleta";
                // Assert (confirmacion)
                Assert.IsInstanceOfType(e, typeof(EntryException));
                Assert.AreEqual(e.Message, message);
            }
        }
コード例 #10
0
ファイル: EditEntryTests.cs プロジェクト: hnidboubker/Logs
        public void TestEditEntry_RepositoryReturnsEntry_ShouldReturnCorrectly(int entryId, string newContent)
        {
            // Arrange
            var mockedLogService       = new Mock <ILogService>();
            var mockedDateTimeProvider = new Mock <IDateTimeProvider>();
            var mockedFactory          = new Mock <ILogEntryFactory>();

            var entry = new LogEntry();

            var mockedRepository = new Mock <IRepository <LogEntry> >();

            mockedRepository.Setup(r => r.GetById(It.IsAny <object>())).Returns(entry);

            var mockedUnitOfWork = new Mock <IUnitOfWork>();

            var service = new EntryService(mockedLogService.Object,
                                           mockedDateTimeProvider.Object,
                                           mockedFactory.Object,
                                           mockedRepository.Object,
                                           mockedUnitOfWork.Object);

            // Act
            var result = service.EditEntry(entryId, newContent);

            // Assert
            Assert.AreSame(entry, result);
        }
コード例 #11
0
        public void GetLastEntryByVehicleBadId_ShouldReturnNull()
        {
            // Arrange (preparación, organizar)
            var entryEntity = new EntryEntity
            {
                CC            = null,
                EntryTime     = DateTime.Now,
                Id            = Guid.NewGuid().ToString(),
                IdVehicle     = "SFL55D",
                IdVehicleType = VehicleTypeEnum.car
            };
            var entryList = new List <EntryEntity>
            {
                entryEntity
            };
            var id = entryEntity.IdVehicle;

            entryRepository.Setup(er => er.List(er => er.IdVehicle == id)).Returns(entryList);

            var entryServiceClass = new EntryService(entryRepository.Object, _cellService.Object, _departureService.Object, _placaService.Object);

            // Act
            var result = entryServiceClass.GetLastEntryByVehicleId("ZFL55D");

            // Assert
            Assert.IsNull(result);
        }
コード例 #12
0
        public static void AddNewOutcome()
        {
            Console.Clear();

            Console.WriteLine("New outcome:");
            Console.WriteLine("Enter outcome name: ");
            string name = Console.ReadLine();

            Console.WriteLine("Enter amount:");
            decimal amount;

            while (!decimal.TryParse(Console.ReadLine(), out amount))
            {
                Console.WriteLine("Please enter valid amount: ");
            }
            ;

            Console.WriteLine("Enter date (YYYY-MM-DD): ");
            DateTime date;

            while (!DateTime.TryParse(Console.ReadLine(), out date))
            {
                Console.WriteLine("Please enter valid date:");
            }
            ;

            IEntryService entryService = new EntryService(_repository);

            entryService.AddNewOutcome(amount, name, date);

            Console.ForegroundColor = ConsoleColor.Red;
            Console.WriteLine("New outcome added");
            ReturnToMenuMessage();
        }
コード例 #13
0
 static ServiceLocator()
 {
     AddressService        = new AddressService();
     BoatService           = new BoatService();
     ClubService           = new ClubService();
     UserService           = new UserService();
     EntryService          = new EntryService();
     RaceEventService      = new RaceEventService();
     RegattaService        = new RegattaService();
     SocialEventService    = new SocialEventService();
     TeamService           = new TeamService();
     EmailService          = new EmailService();
     PhoneNumberService    = new PhoneNumberService();
     RegisteredUserService = new RegisteredUserService();
     ResultService         = new ResultService();
     UserRoleService       = new UserRoleService();
     ClubsUsersUserRolesJunctionsService    = new Clubs_Users_UserRoles_JunctionsService();
     RegattasUsersUserRolesJunctionsService = new Regattas_Users_UserRoles_JunctionsService();
     RegisteredUserSocialEventService       = new RegisteredUser_SocialEventService();
     TeamRaceEventService      = new Team_RaceEventService();
     TeamRegisteredUserService = new Team_RegisteredUserService();
     BoatService = new BoatService();
     SocialEventsUsersUserRolesJunctionsService = new SocialEvents_Users_UserRoles_JunctionsService();
     RaceEventsUsersUserRolesJunctionsService   = new RaceEvents_Users_UserRoles_JunctionsService();
     ClubsEmailsService       = new ClubsEmailsService();
     ClubsPhoneNumbersService = new ClubsPhoneNumbersService();
 }
コード例 #14
0
        public void TestEditEntry_RepositoryReturnsEntry_ShouldCallRepositoryUpdate(int entryId, string newContent)
        {
            // Arrange
            var mockedLogService       = new Mock <ILogService>();
            var mockedDateTimeProvider = new Mock <IDateTimeProvider>();
            var mockedFactory          = new Mock <ILogEntryFactory>();

            var entry = new LogEntry();

            var mockedRepository = new Mock <IRepository <LogEntry> >();

            mockedRepository.Setup(r => r.GetById(It.IsAny <object>())).Returns(entry);

            var mockedUnitOfWork = new Mock <IUnitOfWork>();

            var service = new EntryService(mockedLogService.Object,
                                           mockedDateTimeProvider.Object,
                                           mockedFactory.Object,
                                           mockedRepository.Object,
                                           mockedUnitOfWork.Object);

            // Act
            service.EditEntry(entryId, newContent);

            // Assert
            mockedRepository.Verify(r => r.Update(entry), Times.Once);
        }
コード例 #15
0
        private EntryService CreateEntryService()
        {
            var userId  = Guid.Parse(User.Identity.GetUserId());
            var service = new EntryService(userId);

            return(service);
        }
コード例 #16
0
        public void TestAddEntryToLog_ShouldCallServiceAddEntryToLog(string content, int logId)
        {
            // Arrange
            var mockedLogService       = new Mock <ILogService>();
            var mockedDateTimeProvider = new Mock <IDateTimeProvider>();

            var entry = new LogEntry();

            var mockedFactory = new Mock <ILogEntryFactory>();

            mockedFactory.Setup(f => f.CreateLogEntry(It.IsAny <string>(), It.IsAny <DateTime>(), It.IsAny <int>()))
            .Returns(entry);

            var mockedRepository = new Mock <IRepository <LogEntry> >();
            var mockedUnitOfWork = new Mock <IUnitOfWork>();

            var service = new EntryService(mockedLogService.Object,
                                           mockedDateTimeProvider.Object,
                                           mockedFactory.Object,
                                           mockedRepository.Object,
                                           mockedUnitOfWork.Object);

            // Act
            service.AddEntryToLog(content, logId, null);


            // Assert
            mockedLogService.Verify(s => s.AddEntryToLog(logId, entry, null), Times.Once);
        }
コード例 #17
0
        public Tags(double lat, double longitud)
        {
            InitializeComponent();

            MyMap.CustomPins = new List <CustomPin>();

            Device.BeginInvokeOnMainThread(async() => {
                EntryService entryService = new EntryService();

                List <GeoTaggerEntry> entries = await entryService.GetLastEntries();

                foreach (GeoTaggerEntry entry in entries)
                {
                    var thisPosition = new Position(double.Parse(entry.Lat), double.Parse(entry.Long)); // Latitude, Longitude
                    var pin          = new CustomPin
                    {
                        Type     = PinType.Generic,
                        Position = thisPosition,
                        Label    = entry.Text,
                        Url      = entry.Link
                    };
                    MyMap.CustomPins.Add(pin);
                    MyMap.Pins.Add(pin);
                }
            });

            var mapPosition = new Position(-34, -58);

            MyMap.MoveToRegion(MapSpan.FromCenterAndRadius(mapPosition,
                                                           Distance.FromMiles(1)));
        }
コード例 #18
0
        public void RegisterCar_WithBadIdVehicleFormat_ShouldReturnException()
        {
            // Arrange (preparación, organizar)
            var entryBuilder = new EntryDTOBuilder()
                               .WithVehicleId("SFL55A")
                               .WithVehicleType(VehicleTypeEnum.car);

            DtoEntry entry = entryBuilder.Build();

            _cellService.Setup(cs => cs.ExistsQuotaByVehicleType(VehicleTypeEnum.car)).Returns(true);
            var entryService = new EntryService(entryRepository.Object, _cellService.Object, _departureService.Object, _placaService.Object);

            // Act
            try
            {
                entryService.RegistryVehicle(entry);
            }
            catch (Exception e)
            {
                var message = "Hubo un problema al leer la placa del vehículo. Verifique el tipo de vehículo e intente de nuevo";
                // Assert (confirmacion)
                Assert.IsInstanceOfType(e, typeof(EntryException));
                Assert.AreEqual(e.Message, message);
            }
        }
コード例 #19
0
        public void RegisterVehicle_WithoutCellAvaliable_ShouldReturnException()
        {
            // Arrange (preparación, organizar)
            var entryBuilder = new EntryDTOBuilder()
                               .WithVehicleId("SFL555")
                               .WithVehicleType(VehicleTypeEnum.car);

            _cellService.Setup(cs => cs.ExistsQuotaByVehicleType(VehicleTypeEnum.car)).Returns(false);


            var      entryService = new EntryService(entryRepository.Object, _cellService.Object, _departureService.Object, _placaService.Object);
            DtoEntry entry        = entryBuilder.Build();

            // Act
            try
            {
                entryService.RegistryVehicle(entry);
            }
            catch (Exception e)
            {
                var message = "No hay cupos disponibles";
                // Assert (confirmacion)
                Assert.IsInstanceOfType(e, typeof(CellException));
                Assert.AreEqual(e.Message, message);
            }
        }
コード例 #20
0
        // GET: Entry
        public ActionResult Index()
        {
            var userId  = Guid.Parse(User.Identity.GetUserId());
            var service = new EntryService(userId);
            var model   = service.GetEntries();

            return(View(model));
        }
コード例 #21
0
        public async void ThrowsGivenNullEntryServiceArguments()
        {
            var entryService = new EntryService(null, _mockEntryRepo.Object);

            await Assert.ThrowsAsync <ArgumentNullException>(
                async() => await entryService.SetEntryAsync(null)
                );
        }
コード例 #22
0
        public async void ThrowsGivenInvalidEntryId()
        {
            var entryService = new EntryService(null, _mockEntryRepo.Object);

            await Assert.ThrowsAsync <EntryNotFoundException>(
                async() => await entryService.GetEntryById(_invalidId)
                );
        }
コード例 #23
0
        public void GetById_EntryNotFound_ThrowsEntryNotFoundException()
        {
            var service = new EntryService(_context);

            service
            .Invoking(s => s.GetById(1L))
            .Should()
            .Throw <EntryNotFoundException>();
        }
コード例 #24
0
        public void Update_EntryNotFound_ThrowsException()
        {
            var service = new EntryService(_context);

            service
            .Invoking(s => s.Update(new EntryDto()))
            .Should()
            .Throw <EntryNotFoundException>();
        }
コード例 #25
0
        public void Add_JournalNotFound_ThrowsJournalNotFoundException()
        {
            var service = new EntryService(_context);

            service
            .Invoking(s => s.Add(1L, new EntryDto()))
            .Should()
            .Throw <JournalNotFoundException>();
        }
コード例 #26
0
        public ActionResult Badges()
        {
            EntryService entryService = CreateEntryService();
            var          userId       = User.Identity.GetUserId();

            var model = entryService.GetEntryAndGoalCount(userId);

            return(View(model));
        }
コード例 #27
0
        public async Task GetAllByJournal_JournalNotFound_ReturnsNull()
        {
            // Act
            var service = new EntryService(_context);
            var result  = await service.GetAllByJournal(1L);

            // Assert
            result.Should().BeNull();
        }
コード例 #28
0
        public void Register()
        {
            //Setup the connection with the message broker

            //////////////////
            TextWriter oldOut = Console.Out;
            /////////////////

            ConnectionFactory factory  = new ConnectionFactory();
            IProtocol         protocol = Protocols.AMQP_0_9_1;

            factory.VirtualHost = virtualHost;
            factory.UserName    = userName;
            factory.Password    = password;
            factory.HostName    = hostName;
            factory.Port        = port;
            factory.Protocol    = protocol;
            IConnection conn    = factory.CreateConnection();
            IModel      channel = conn.CreateModel();

            uint messageCount = GetMessageCount(factory, queueName);

            EntryService.CreateGeneralAuditoria(Environment.MachineName, Environment.UserName, messageCount);

            if (messageCount == 0)
            {
                EntryService.CreateEntryAuditoria(Environment.MachineName, Environment.UserName, new Entries());
                Environment.Exit(0);
            }
            else
            {
                int messageCountIndex = 0;
                var consumer          = new EventingBasicConsumer(channel);

                consumer.Received += (ch, ea) =>
                {
                    var      body    = ea.Body;
                    string   message = Encoding.UTF8.GetString(body);
                    EntryDTO result  = JsonConvert.DeserializeObject <EntryDTO>(message);

                    EntryService.CreateEntryAuditoria(Environment.MachineName, Environment.UserName, result.entries);

                    if (EntryService.CreateNotaEntry(result.entries))
                    {
                        channel.BasicAck(ea.DeliveryTag, false);
                    }
                    messageCountIndex++;
                };

                if (messageCountIndex == messageCount)
                {
                    Environment.Exit(0);
                }
                String consumerTag = channel.BasicConsume(queueName, false, consumer);
            }
        }
コード例 #29
0
        public void MoveEntryToJournal_JournalNotFound_ThrowsMoveEntryException()
        {
            // Act & assert
            var service = new EntryService(_context);

            service
            .Invoking(s => s.MoveEntryToJournal(1L, 1L))
            .Should()
            .Throw <MoveEntryException>();
        }
コード例 #30
0
        static void Main6(string[] args)
        {
            DataTable dt = ExcelHelper.GetDataTable("D:/培训导入.xlsx");

            IEntryService entryService = new EntryService();
            bool          b            = entryService.EntryImport(3, 14, 38, dt);

            Console.WriteLine(b);
            Console.ReadKey();
        }
コード例 #31
0
        public static IEntryService SetupEntryService()
        {
            var entryRepository = new Mock<IEntryRepository>();
            var locationRepository = new Mock<ILocationRepository>();
            var tagRepository = new Mock<ITagRepository>();
            var timeLineServiceStub = new Mock<ITimelineColorService>();
            var timeServiceStub = new Mock<ITimeService>();
            var scopeStub = new Mock<IScope>();

            var entryService = new EntryService(
                entryRepository.Object,
                locationRepository.Object,
                tagRepository.Object,
                timeLineServiceStub.Object,
                timeServiceStub.Object,
                scopeStub.Object);

            return entryService;
        }
コード例 #32
0
 protected override void ExecuteTest()
 {
     var service = new EntryService(userEntryProvider);
     actualUrl = service.Get(EntryRequest.Create(suppliedLocalEducationAgencyId, null));
 }
コード例 #33
0
 protected override void ExecuteTest()
 {
     try
     {
         var service = new EntryService(userEntryProvider);
         actualModel = service.Get(EntryRequest.Create(suppliedLocalEducationAgencyId, suppliedSchoolId));
     }
     catch (Exception ex)
     {
         actualException = ex;
     }
 }