Esempio n. 1
0
        public async Task AddAsync__In_resource_exists_the_same_ticket_but_with_different_ticket_id__Should_throw_InvalidOperationException()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    context.Tickets.Add(_validTicket);
                    await context.SaveChangesAsync();
                }

                using (var context = await factory.CreateContextAsync())
                {
                    var service = new TicketDbService(context, _logger);
                    var ticket  = _validTicket.Clone() as Ticket;

                    // Assign existing customer, discount, ticket tariff and sightseeing group to the ticket to be added, based on their Ids.
                    // Each ticket is a child of mentioned entities and cannot exist without their.
                    // Moreover, it is impossible to add a new parent by adding a ticket that references a non-existent parent.
                    // In this case, an exception will be thrown.
                    ticket.Customer = await context.Customers.SingleAsync(x => x.Id.Equals(_validTicket.Customer.Id));

                    ticket.Discount = await context.Discounts.SingleAsync(x => x.Id.Equals(_validTicket.Discount.Id));

                    ticket.Tariff = await context.TicketTariffs.SingleAsync(x => x.Id.Equals(_validTicket.Tariff.Id));

                    ticket.Group = await context.Groups.SingleAsync(x => x.Id.Equals(_validTicket.Group.Id));

                    Func <Task> action = async() => await service.AddAsync(ticket);

                    await action.Should().ThrowExactlyAsync <InvalidOperationException>("Because in resource exists the Ticket with the same id as this one to be added.");
                }
            }
        }
Esempio n. 2
0
        public async Task AddAsync__In_resource_exists_the_same_ticket_but_with_different_ticket_id_and_id__Should_add_this_ticket_successful()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    context.Tickets.Add(_validTicket);
                    await context.SaveChangesAsync();
                }

                using (var context = await factory.CreateContextAsync())
                {
                    var service = new TicketDbService(context, _logger);
                    var ticket  = _validTicket.Clone() as Ticket;
                    ticket.Id      += "_changed_id";
                    ticket.Customer = await context.Customers.SingleAsync(x => x.Id.Equals(_validTicket.Customer.Id));

                    ticket.Discount = await context.Discounts.SingleAsync(x => x.Id.Equals(_validTicket.Discount.Id));

                    ticket.Tariff = await context.TicketTariffs.SingleAsync(x => x.Id.Equals(_validTicket.Tariff.Id));

                    ticket.Group = await context.Groups.SingleAsync(x => x.Id.Equals(_validTicket.Group.Id));

                    var result = await service.AddAsync(ticket);

                    result.Should().BeEquivalentTo(ticket);
                }
            }
        }
Esempio n. 3
0
        public async Task GetWithPaginationAsync__Number_of_elements_on_single_page_is_less_than_page_size__Should_return_all_these_elements()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    context.Tickets.RemoveRange(await context.Tickets.ToArrayAsync());
                    await context.SaveChangesAsync();
                }

                using (var context = await factory.CreateContextAsync())
                {
                    for (int i = 0; i < 10; i++)
                    {
                        await context.Tickets.AddAsync(new Ticket { Id = i.ToString() });
                    }
                    await context.SaveChangesAsync();
                }

                using (var context = await factory.CreateContextAsync())
                {
                    var service = new TicketDbService(context, _logger);

                    // Page will be first with 6 elements and second with 4 elements. Second page will be return.
                    var result = await service.GetWithPaginationAsync(2, 6);

                    // More generic solution is: Count() should be count of elements in resource % pageSize.
                    result.Count().Should().Be(4);
                }
            }
        }
Esempio n. 4
0
        public async Task GetWithPaginationAsync__Page_size_is_negative__Should_throw_ArgumentOutOfRangeException()
        {
            var service = new TicketDbService(_dbContextMock.Object, _logger);

            Func <Task> action = async() => await service.GetWithPaginationAsync(3, -10);

            await action.Should().ThrowExactlyAsync <ArgumentOutOfRangeException>("Because page size cannot be negative number.");
        }
Esempio n. 5
0
        public async Task AddAsync__Argument_is_null__Should_throw_ArgumentNullException()
        {
            var service = new TicketDbService(_dbContextMock.Object, _logger);

            Func <Task> result = async() => await service.AddAsync(null as Ticket);

            await result.Should().ThrowExactlyAsync <ArgumentNullException>("Because argument 'Ticket' is null.");
        }
Esempio n. 6
0
        public async Task GetAsync__Id_is_null_or_empty__Should_throw_ArgumentException([Values(null, "")] string id)
        {
            var service = new TicketDbService(_dbContextMock.Object, _logger);

            Func <Task> action = async() => await service.GetAsync(id);

            await action.Should().ThrowExactlyAsync <ArgumentException>("Because id cannot be null or empty string.");
        }
Esempio n. 7
0
        public async Task GetWithPaginationAsync__Page_number_is_less_than_1__Should_throw_ArgumentOutOfRangeException()
        {
            var service = new TicketDbService(_dbContextMock.Object, _logger);

            Func <Task> action = async() => await service.GetWithPaginationAsync(0, 10);

            await action.Should().ThrowExactlyAsync <ArgumentOutOfRangeException>("Because page number cannot be less than 1.");
        }
Esempio n. 8
0
        public async Task AddAsync__Add_successful__Resource_contains_added_ticket_tariff()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    var service = new TicketDbService(context, _logger);

                    await service.AddAsync(_validTicket);

                    context.Tickets.Contains(_validTicket).Should().BeTrue();
                }
            }
        }
Esempio n. 9
0
        public async Task GetByAsync__Argument_predicate_is_null__Should_throw_ArgumentNullException()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    var service = new TicketDbService(context, _logger);

                    Func <Task> action = async() => await service.GetByAsync(null);

                    await action.Should().ThrowExactlyAsync <ArgumentNullException>();
                }
            }
        }
Esempio n. 10
0
        public async Task GetAsync__Found_zero_matching_ticket__Should_throw_InvalidOperationException()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    var service = new TicketDbService(context, _logger);

                    Func <Task> action = async() => await service.GetAsync("a");

                    await action.Should().ThrowExactlyAsync <InvalidOperationException>("Because Ticket not found.");
                }
            }
        }
Esempio n. 11
0
        public async Task AddAsync__Add_successful__Should_return_added_ticket_tariff()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    var service = new TicketDbService(context, _logger);

                    var result = await service.AddAsync(_validTicket);

                    result.Should().BeEquivalentTo(_validTicket);
                }
            }
        }
Esempio n. 12
0
        public async Task GetWithPaginationAsync__Resource_is_null__Should_throw_InternalDbServiceException()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    context.Tickets = null as DbSet <Ticket>;
                    var service = new TicketDbService(context, _logger);

                    Func <Task> action = async() => await service.GetWithPaginationAsync(1, 1);

                    await action.Should().ThrowExactlyAsync <InternalDbServiceException>("Because resource reference is set to null");
                }
            }
        }
Esempio n. 13
0
        public async Task AddAsync__Add_successful__Resource_length_should_be_greater_by_1()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    int expectedLength = context.Tickets.Count() + 1;
                    var service        = new TicketDbService(context, _logger);

                    await service.AddAsync(_validTicket);

                    context.Tickets.Count().Should().Be(expectedLength);
                }
            }
        }
Esempio n. 14
0
        public async Task GetByAsync__None_ticket_tariffs_satisfy_predicate__Should_return_empty_IEnumerable()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    var service = new TicketDbService(context, _logger);

                    // This predicate filters tariffs with CreatedAt equals DateTime.MaxValue. It will none tariffs.
                    var result = await service.GetByAsync(x => x.CreatedAt == DateTime.MaxValue);

                    result.Count().Should().Be(0);
                }
            }
        }
Esempio n. 15
0
        public async Task GetAllAsync__All_tickets_found__Should_return_IEnumerable_for_all_tickets()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    int expectedLength = context.Tickets.ToArray().Length;
                    var service        = new TicketDbService(context, _logger);

                    var result = await service.GetAllAsync();

                    result.Count().Should().Be(expectedLength);
                }
            }
        }
Esempio n. 16
0
        public async Task GetByAsync__At_least_one_ticket_tariffs_found__Should_return_IEnumerable_for_this_tarifs()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    int expectedLength = context.Tickets.ToArray().Length;
                    var service        = new TicketDbService(context, _logger);

                    // This predicate filters tariffs with CreatedAt after DateTime.MinValue. It will be all of tariffs.
                    var result = await service.GetByAsync(_predicate);

                    result.Count().Should().Be(expectedLength);
                }
            }
        }
Esempio n. 17
0
        public async Task GetAsync__Resource_is_empty__Should_throw_InvalidOperationException()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    context.Tickets.RemoveRange(await context.Tickets.ToListAsync());
                    await context.SaveChangesAsync();
                }

                using (var context = await factory.CreateContextAsync())
                {
                    var service = new TicketDbService(context, _logger);

                    Func <Task> action = async() => await service.GetAsync("a");

                    await action.Should().ThrowExactlyAsync <InvalidOperationException>("Because resource is empty and cannot get single instance of Ticket.");
                }
            }
        }
Esempio n. 18
0
        public async Task GetWithPaginationAsync__Resource_is_empty__Should_return_empty_IEnumerable()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    context.Tickets.RemoveRange(await context.Tickets.ToArrayAsync());
                    await context.SaveChangesAsync();
                }

                using (var context = await factory.CreateContextAsync())
                {
                    var service = new TicketDbService(context, _logger);

                    var result = await service.GetWithPaginationAsync(4, 5);

                    result.Count().Should().Be(0);
                }
            }
        }
Esempio n. 19
0
        public async Task GetByAsync__Resource_does_not_exist__Should_throw_InternalDbServiceException()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    // Drop Tickets table.
                    context.Database.ExecuteSqlCommand("DROP TABLE [Tickets]");
                }

                using (var context = await factory.CreateContextAsync())
                {
                    var service = new TicketDbService(context, _logger);

                    Func <Task> action = async() => await service.GetByAsync(_predicate);

                    await action.Should().ThrowExactlyAsync <InternalDbServiceException>("Because resource doesnt exist and cannot get single instance of Ticket. " +
                                                                                         "NOTE Excaption actually is type of 'SqLiteError' only if database provider is SQLite.");
                }
            }
        }
Esempio n. 20
0
        public async Task GetAsync__Ticket_found__Should_return_this_ticket()
        {
            Ticket expectedTicket;

            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    expectedTicket = await context.Tickets.FirstOrDefaultAsync();
                }

                using (var context = await factory.CreateContextAsync())
                {
                    var service = new TicketDbService(context, _logger);

                    var result = await service.GetAsync(expectedTicket.Id);

                    result.Should().BeEquivalentTo(expectedTicket);
                }
            }
        }
Esempio n. 21
0
        public async Task AddAsync__In_resource_exists_the_same_ticket_as_this_one_to_be_added__Should_throw_InvalidOperationException()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    context.Tickets.Add(_validTicket);
                    await context.SaveChangesAsync();
                }

                using (var context = await factory.CreateContextAsync())
                {
                    // Testing method
                    var service = new TicketDbService(context, _logger);

                    Func <Task> result = async() => await service.AddAsync(_validTicket);

                    await result.Should().ThrowExactlyAsync <InvalidOperationException>("Because in resource exists the same Ticket as this one to be added.");
                }
            }
        }
Esempio n. 22
0
        public async Task GetWithPaginationAsync__There_are_not_elements_on_single_page__Should_return_empty_IEnumerable()
        {
            using (var factory = new DbContextFactory())
            {
                using (var context = await factory.CreateContextAsync())
                {
                    for (int i = 0; i < 10; i++)
                    {
                        await context.Tickets.AddAsync(new Ticket { Id = i.ToString() });
                    }
                    await context.SaveChangesAsync();
                }

                using (var context = await factory.CreateContextAsync())
                {
                    var service = new TicketDbService(context, _logger);

                    // In this case is only 2 pages with any data.
                    var result = await service.GetWithPaginationAsync(4, 5);

                    result.Count().Should().Be(0);
                }
            }
        }