public async Task UpdateAsync_given_existing_character_Updates_properties()
        {
            var context = new Mock <IFuturamaContext>();
            var entity  = new Character {
                Id = 42
            };

            context.Setup(c => c.Characters.FindAsync(42)).ReturnsAsync(entity);

            using (var repository = new CharacterRepository(context.Object))
            {
                var character = new CharacterCreateUpdateDTO
                {
                    Id      = 42,
                    ActorId = 12,
                    Name    = "Name",
                    Species = "Species",
                    Planet  = "Planet"
                };

                await repository.UpdateAsync(character);
            }

            Assert.Equal(12, entity.ActorId);
            Assert.Equal("Name", entity.Name);
            Assert.Equal("Species", entity.Species);
            Assert.Equal("Planet", entity.Planet);
        }
        public async Task UpdateAsync_given_non_existing_dto_returns_false()
        {
            using (var connection = await CreateConnectionAsync())
                using (var context = await CreateContextAsync(connection))
                {
                    context.Actors.Add(new Actor {
                        Name = "John DiMaggio"
                    });
                    await context.SaveChangesAsync();

                    var repository = new CharacterRepository(context);
                    var dto        = new CharacterCreateUpdateDTO
                    {
                        Id      = 1,
                        ActorId = 1,
                        Name    = "Bender",
                        Species = "Robot",
                        Planet  = "Earth"
                    };

                    var updated = await repository.UpdateAsync(dto);

                    Assert.False(updated);
                }
        }
Esempio n. 3
0
        public async Task CreateAsync_given_dto_returns_created_Character()
        {
            using (var connection = await CreateConnectionAsync())
                using (var context = await CreateContextAsync(connection))
                {
                    context.Actors.Add(new Actor {
                        Name = "John DiMaggio"
                    });
                    await context.SaveChangesAsync();

                    var repository = new CharacterRepository(context);
                    var dto        = new CharacterCreateUpdateDTO
                    {
                        ActorId = 1,
                        Name    = "Bender",
                        Species = "Robot",
                        Planet  = "Earth"
                    };

                    var character = await repository.CreateAsync(dto);

                    Assert.Equal(1, character.Id);
                    Assert.Equal(1, character.ActorId);
                    Assert.Equal("Bender", character.Name);
                    Assert.Equal("Robot", character.Species);
                    Assert.Equal("Earth", character.Planet);
                }
        }
        public void Create_given_a_character_it_maps_to_character()
        {
            var character = default(Character);
            var dto       = new CharacterCreateUpdateDTO
            {
                ActorId = 42,
                Name    = "Turange Leela",
                Species = "Mutant, Human",
                Planet  = "Earth"
            };

            var mock = new Mock <IFuturamaContext>();

            mock.Setup(s => s.Characters.Add(It.IsAny <Character>()))
            .Callback <Character>(c => character = c);

            using (var repository = new CharacterRepository(mock.Object))
            {
                repository.Create(dto);
            }

            Assert.Equal(42, character.ActorId);
            Assert.Equal("Turange Leela", character.Name);
            Assert.Equal("Mutant, Human", character.Species);
            Assert.Equal("Earth", character.Planet);
        }
Esempio n. 5
0
        public EditCharacterPage(CharacterCreateUpdateDTO character)
        {
            InitializeComponent();

            BindingContext        = _viewModel = DependencyService.Resolve <EditCharacterViewModel>();
            _viewModel.Navigation = Navigation;
            _viewModel.Init(character);
        }
Esempio n. 6
0
        public async Task <ActionResult <CharacterDTO> > Post([FromBody] CharacterCreateUpdateDTO character)
        {
            //if (!ModelState.IsValid)
            //{
            //    return BadRequest(ModelState);
            //}

            var dto = await _repository.CreateAsync(character);

            return(CreatedAtAction(nameof(Get), new { id = dto.Id }, dto));
        }
Esempio n. 7
0
        public async Task <IActionResult> Post([FromBody] CharacterCreateUpdateDTO character)
        {
            if (!ModelState.IsValid)
            {
                return(BadRequest(ModelState));
            }

            var id = await _repository.CreateAsync(character);

            return(CreatedAtAction(nameof(Get), new { id }, null));
        }
Esempio n. 8
0
        public async Task <IActionResult> Put(int id, [FromBody] CharacterCreateUpdateDTO character)
        {
            var updated = await _repository.UpdateAsync(character);

            if (updated)
            {
                return(NoContent());
            }

            return(NotFound());
        }
        public async Task Create_given_invalid_character_returns_BadRequest()
        {
            var character  = new CharacterCreateUpdateDTO();
            var repository = new Mock <ICharacterRepository>();

            var controller = new CharactersController(repository.Object);

            controller.ModelState.AddModelError(string.Empty, "Error");

            var response = await controller.Post(character);

            Assert.IsType <BadRequestObjectResult>(response);
        }
Esempio n. 10
0
        public async Task <CharacterDTO> CreateAsync(CharacterCreateUpdateDTO character)
        {
            var entity = new Character
            {
                ActorId = character.ActorId,
                Name    = character.Name,
                Species = character.Species,
                Planet  = character.Planet,
            };

            _context.Characters.Add(entity);
            await _context.SaveChangesAsync();

            return(await FindAsync(entity.Id));
        }
        public async Task Create_given_character_returns_CreateAtAction()
        {
            var character = new CharacterCreateUpdateDTO {
                Name = "New guy", Species = "Human"
            };
            var repository = new Mock <ICharacterRepository>();

            repository.Setup(r => r.CreateAsync(character)).ReturnsAsync(42);

            var controller = new CharactersController(repository.Object);

            var response = await controller.Post(character) as CreatedAtActionResult;

            Assert.Equal("Get", response.ActionName);
            Assert.Equal(42, response.RouteValues["id"]);
        }
Esempio n. 12
0
        public int Create(CharacterCreateUpdateDTO character)
        {
            var entity = new Character
            {
                ActorId = character.ActorId,
                Name    = character.Name,
                Species = character.Species,
                Planet  = character.Planet,
            };

            _context.Characters.Add(entity);

            _context.SaveChanges();

            return(entity.Id);
        }
        public async Task Create_given_character_calls_SaveChangesAsync()
        {
            var context = new Mock <IFuturamaContext>();

            context.Setup(c => c.Characters.Add(It.IsAny <Character>()));

            using (var repository = new CharacterRepository(context.Object))
            {
                var character = new CharacterCreateUpdateDTO
                {
                    Name    = "Name",
                    Species = "Species",
                };
                await repository.CreateAsync(character);
            }

            context.Verify(c => c.SaveChangesAsync(default(CancellationToken)));
        }
Esempio n. 14
0
        public async Task <bool> UpdateAsync(CharacterCreateUpdateDTO character)
        {
            var entity = await _context.Characters.FindAsync(character.Id);

            if (entity == null)
            {
                return(false);
            }

            entity.ActorId = character.ActorId;
            entity.Name    = character.Name;
            entity.Species = character.Species;
            entity.Planet  = character.Planet;

            await _context.SaveChangesAsync();

            return(true);
        }
Esempio n. 15
0
        public async Task UpdateAsync_given_non_existing_dto_returns_false()
        {
            using (var connection = await CreateConnectionAsync())
                using (var context = await CreateContextAsync(connection))
                {
                    var repository = new CharacterRepository(context);
                    var dto        = new CharacterCreateUpdateDTO
                    {
                        Id      = 0,
                        Name    = "Bender",
                        Species = "Robot",
                        Planet  = "Earth"
                    };

                    var updated = await repository.UpdateAsync(dto);

                    Assert.False(updated);
                }
        }
        public async Task Update_given_non_existing_character_returns_false()
        {
            var context = new Mock <IFuturamaContext>();

            context.Setup(c => c.Characters.FindAsync(42)).ReturnsAsync(default(Character));

            using (var repository = new CharacterRepository(context.Object))
            {
                var character = new CharacterCreateUpdateDTO
                {
                    Id      = 42,
                    Name    = "Name",
                    Species = "Species",
                };

                var result = await repository.UpdateAsync(character);

                Assert.False(result);
            }
        }
        public async Task Update_given_non_existing_character_does_not_SaveChangesAsync()
        {
            var context = new Mock <IFuturamaContext>();

            context.Setup(c => c.Characters.FindAsync(42)).ReturnsAsync(default(Character));

            using (var repository = new CharacterRepository(context.Object))
            {
                var character = new CharacterCreateUpdateDTO
                {
                    Id      = 42,
                    Name    = "Name",
                    Species = "Species",
                };

                await repository.UpdateAsync(character);
            }

            context.Verify(c => c.SaveChangesAsync(default(CancellationToken)), Times.Never);
        }
Esempio n. 18
0
        public async Task UpdateAsync_given_existing_dto_updates_entity()
        {
            using (var connection = await CreateConnectionAsync())
                using (var context = await CreateContextAsync(connection))
                {
                    context.Actors.Add(new Actor {
                        Name = "John DiMaggio"
                    });
                    await context.SaveChangesAsync();

                    context.Characters.Add(new Character {
                        Name = "Fry", Species = "Human"
                    });
                    await context.SaveChangesAsync();

                    var repository = new CharacterRepository(context);
                    var dto        = new CharacterCreateUpdateDTO
                    {
                        Id      = 1,
                        ActorId = 1,
                        Name    = "Bender",
                        Species = "Robot",
                        Planet  = "Earth"
                    };

                    var updated = await repository.UpdateAsync(dto);

                    Assert.True(updated);

                    var entity = await context.Characters.FindAsync(1);

                    Assert.Equal(1, entity.ActorId);
                    Assert.Equal("Bender", entity.Name);
                    Assert.Equal("Robot", entity.Species);
                    Assert.Equal("Earth", entity.Planet);
                }
        }
        public async Task Create_given_character_returns_new_Id()
        {
            var entity = default(Character);

            var context = new Mock <IFuturamaContext>();

            context.Setup(c => c.Characters.Add(It.IsAny <Character>()))
            .Callback <Character>(t => entity = t);
            context.Setup(c => c.SaveChangesAsync(default(CancellationToken)))
            .Returns(Task.FromResult(0))
            .Callback(() => entity.Id = 42);

            using (var repository = new CharacterRepository(context.Object))
            {
                var character = new CharacterCreateUpdateDTO
                {
                    Name    = "Name",
                    Species = "Species",
                };
                var id = await repository.CreateAsync(character);

                Assert.Equal(42, id);
            }
        }
        public async Task CreateAsync_given_character_adds_it()
        {
            var entity  = default(Character);
            var context = new Mock <IFuturamaContext>();

            context.Setup(c => c.Characters.Add(It.IsAny <Character>())).Callback <Character>(t => entity = t);

            using (var repository = new CharacterRepository(context.Object))
            {
                var character = new CharacterCreateUpdateDTO
                {
                    ActorId = 1,
                    Name    = "Name",
                    Species = "Species",
                    Planet  = "Planet"
                };
                await repository.CreateAsync(character);
            }

            Assert.Equal(1, entity.ActorId);
            Assert.Equal("Name", entity.Name);
            Assert.Equal("Species", entity.Species);
            Assert.Equal("Planet", entity.Planet);
        }
Esempio n. 21
0
 public void Update(CharacterCreateUpdateDTO character)
 {
     throw new NotImplementedException();
 }
Esempio n. 22
0
        public async Task <CharacterDTO> CreateAsync(CharacterCreateUpdateDTO character)
        {
            var response = await _client.PostAsJsonAsync("api/characters", character);

            return(await response.Content.ReadAsAsync <CharacterDTO>());
        }
Esempio n. 23
0
        public async Task <bool> UpdateAsync(CharacterCreateUpdateDTO character)
        {
            var response = await _client.PutAsJsonAsync($"api/characters/{character.Id}", character);

            return(response.IsSuccessStatusCode);
        }
Esempio n. 24
0
 public Task UpdateAsync(CharacterCreateUpdateDTO character)
 {
     throw new NotImplementedException();
 }
Esempio n. 25
0
        public async Task <ActionResult <CharacterDTO> > Post([FromBody] CharacterCreateUpdateDTO character)
        {
            var dto = await _repository.CreateAsync(character);

            return(CreatedAtAction(nameof(Get), new { id = dto.Id }, dto));
        }