public void AddProductToCard_Success_Result()
{
var requestModel = new CreateProductToCardCommand()
{
CustomerID = new Guid("88549f74-6cef-4a40-86a7-dc34086bdfe1"),
ProductID = new Guid("88549f74-6cef-4a40-86a7-dc34086bdfe2"),
Quantity = 3
};
var responseModel = new ProductToCardResponse(new Guid("88549f74-6cef-4a40-86a7-dc34086bdfe2"),
new List <CardItemResponse>()
{
new CardItemResponse(new Guid("88549f74-6cef-4a40-86a7-dc34086bdfe5"), 3)
},
true
);
Mediator.Setup(x => x.Send(It.IsAny <CreateProductToCardCommand>(), new System.Threading.CancellationToken())).
ReturnsAsync(responseModel);
var cardsController = new CardsController(Mediator.Object);
//Action
var response = cardsController.AddProductToCard(requestModel);
//Assert
var result = Assert.IsType <OkObjectResult>(response.Result);
Assert.Equal(200, result.StatusCode);
}
public void ShouldForbidWhenCardsAddingRequestIsNotDoneByAdmin()
{
//Arrange
var catalogId = 1;
var adminUserId = 2;
var catalogForDb = new Catalog(_catalogRepositoryMock.Object, _cardEventHandlerMock.Object);
catalogForDb.Id = catalogId;
var input = new CardDto
{
UserId = 1,
CardId = 1,
CardVersion = 2
};
var cards = new List <Card> {
new Card(input.CardId, input.CardVersion)
};
_mapperMock.Setup(v => v.Map <IList <Card> >(It.IsAny <IEnumerable <CardDto> >())).Returns(cards);
_catalogRepositoryMock.Setup(v => v.GetCatalog(catalogId)).Returns(catalogForDb);
_catalogRepositoryMock.Setup(v => v.GetAllAdminIds(catalogId)).Returns(new List <int> {
adminUserId
});
var cardsController = new CardsController(_catalogRepositoryMock.Object, _cardEventHandlerMock.Object, _mapperMock.Object, _loggerMock.Object);
//Act
var response = cardsController.AddCards(new List <CardDto> {
input
}, catalogId);
//Assert
Assert.IsNotNull(response.Result as ForbidResult);
}
public async Task CreateCard_RightObjectPassed_ReturnsCreatedAtAction()
{
// Arrange
var controller = new CardsController(flashcardDbContextMock.Object, logger);
var rightCard = new CardDTO
{
Type = "Teszt tipus",
Card_number = 3,
Question_text = "Teszt kartya kerdes",
Question_picture = "kep.jpg",
Answer_text = "Teszt kartya valasz",
Answer_picture = "kep2.jpg",
Deck = new DeckInfoDTO
{
Id = 1,
Name = "Teszt csomag",
Module = Module.A,
Deck_number = 1,
Status = DeckStatus.Approved
}
};
// Act
var result = await controller.CreateCard(rightCard);
// Asssert
Assert.IsType <CreatedAtActionResult>(result.Result);
}
public async Task UpdateCardFromDeckById_Method_Returns_NoContent_DeckExist_CardExist()
{
//Arrange
var mockRepository = new Mock <IFlashcardDataRepository>();
mockRepository.Setup(x => x.isDeckExist(1)).Returns((int id) => Task.FromResult(true));
mockRepository.Setup(x => x.UpdateCardFromDeckByCardId(1, 1, "q1", "a1"))
.Returns((int id, int cardId, string questionText, string answerText) => Task.FromResult(true));
CardsController cardsController = new CardsController(mockRepository.Object, iMapper);
Card card = new Card()
{
Id = 1,
DeckId = 1,
QuestionText = "q1",
AnswerText = "a1"
};
//Act
var result = await cardsController.UpdateCardFromDeckById(1, 1, card);
//Assert
var noContentResult = Assert.IsType <NoContentResult>(result);
Assert.Equal(StatusCodes.Status204NoContent, noContentResult.StatusCode);
}
public void ShouldReturnNotFoundWhenEditIsCalledForInvalidCatalog()
{
//Arrange
var catalogId = 1;
var catalogForDb = new Catalog(_catalogRepositoryMock.Object, _cardEventHandlerMock.Object);
catalogForDb.Id = catalogId;
var input = new CardDto
{
UserId = 1,
CardId = 1,
CardVersion = 2
};
var pendingCards = new List <PendingCard> {
new PendingCard(input.CardId, input.CardVersion)
};
_mapperMock.Setup(v => v.Map <IList <PendingCard> >(It.IsAny <IEnumerable <CardDto> >())).Returns(pendingCards);
_catalogRepositoryMock.Setup(v => v.GetCatalog(catalogId)).Returns(catalogForDb);
var cardsController = new CardsController(_catalogRepositoryMock.Object, _cardEventHandlerMock.Object, _mapperMock.Object, _loggerMock.Object);
//Act
var response = cardsController.EditCard(new List <CardDto> {
input
}, 2);
//Assert
Assert.AreEqual((int)HttpStatusCode.NotFound, (response.Result as NotFoundResult).StatusCode);
}
public async Task GetCardsTest()
{
using DbContext context = CreateContext();
CardsController controller = CreateController(context);
Dictionary <string, object> parameters = new Dictionary <string, object>();
//Get all cards of user
ActionResult <List <Card> > result = await controller.GetAsync(parameters);
Assert.AreEqual(1, result.Value.Count);
Assert.AreEqual(card.CardId, result.Value[0].CardId);
Assert.AreEqual(deck.DeckId, result.Value[0].Deck.DeckId);
Assert.AreEqual(template.CardTemplateId, result.Value[0].CardTemplate.CardTemplateId);
Assert.AreEqual(field1.FieldName, result.Value[0].Fields[0].FieldName);
Assert.AreEqual(field2.FieldName, result.Value[0].Fields[1].FieldName);
//Get all cards of deck
parameters.Add(nameof(Deck.DeckId), deck.DeckId);
result = await controller.GetAsync(parameters);
Assert.AreEqual(1, result.Value.Count);
Assert.AreEqual(card.CardId, result.Value[0].CardId);
Assert.AreEqual(deck.DeckId, result.Value[0].Deck.DeckId);
Assert.AreEqual(template.CardTemplateId, result.Value[0].CardTemplate.CardTemplateId);
Assert.AreEqual(field1.FieldName, result.Value[0].Fields[0].FieldName);
Assert.AreEqual(field2.FieldName, result.Value[0].Fields[1].FieldName);
//Get all cards of not existing deck
parameters[nameof(Deck.DeckId)] = (long)2;
result = await controller.GetAsync(parameters);
Assert.AreEqual(0, result.Value.Count);
}
public async Task GetCardsWithSearchTextTest()
{
using DbContext context = CreateContext();
CardsController controller = CreateController(context);
Dictionary <string, object> parameters = new Dictionary <string, object>()
{
{ EntityControllerBase <Card, long> .SearchTextParameter, "test123" }
};
//No cards matching the search text
ActionResult <List <Card> > result = await controller.GetAsync(parameters);
Assert.AreEqual(0, result.Value.Count);
//Search text is card id
parameters[EntityControllerBase <Card, long> .SearchTextParameter] = "1";
result = await controller.GetAsync(parameters);
Assert.AreEqual(1, result.Value.Count);
Assert.AreEqual(card.CardId, result.Value[0].CardId);
//Deck title contains the search text
parameters[EntityControllerBase <Card, long> .SearchTextParameter] = "fault";
result = await controller.GetAsync(parameters);
Assert.AreEqual(1, result.Value.Count);
Assert.AreEqual(card.CardId, result.Value[0].CardId);
//One of the field names contains the search text
parameters[EntityControllerBase <Card, long> .SearchTextParameter] = "Fro";
result = await controller.GetAsync(parameters);
Assert.AreEqual(1, result.Value.Count);
Assert.AreEqual(card.CardId, result.Value[0].CardId);
}
public async Task Post_Method_Returns_CreatedAtAction_DeckExists()
{
//Arrange
var mockRepository = new Mock <IFlashcardDataRepository>();
mockRepository.Setup(x => x.isDeckExist(1)).Returns((int id) => Task.FromResult(true));
mockRepository.Setup(x => x.AddCardToDeck(1, "q1", "a1"))
.Returns((int id, string questionText, string answerText) => Task.FromResult(new Card()
{
Id = id, QuestionText = questionText, AnswerText = answerText
}));
CardsController cardsController = new CardsController(mockRepository.Object, iMapper);
CardRequest cardRequest = new CardRequest()
{
QuestionText = "q1",
AnswerText = "a1"
};
//Act
var result = await cardsController.Post(1, cardRequest);
//Assert
var createAtActionResult = Assert.IsType <CreatedAtActionResult>(result);
var cardResponseDto = Assert.IsType <CardResponseDto>(createAtActionResult.Value);
Assert.Equal(1, cardResponseDto.Id);
Assert.Equal("q1", cardResponseDto.QuestionText);
Assert.Equal("a1", cardResponseDto.AnswerText);
}
public async Task GetCardByIdTest()
{
using DbContext context = CreateContext();
CardsController controller = CreateController(context);
//get card successfully
ActionResult <Card> result = await controller.GetAsync(1);
Assert.IsNotNull(result.Value);
Assert.AreEqual(deck.DeckId, result.Value.Deck.DeckId);
Assert.AreEqual(template.CardTemplateId, result.Value.CardTemplate.CardTemplateId);
Assert.AreEqual(field1.FieldName, result.Value.Fields[0].FieldName);
Assert.AreEqual(field2.FieldName, result.Value.Fields[1].FieldName);
Assert.AreEqual(fieldDefinition1.FieldId, result.Value.Fields[0].CardFieldDefinition.FieldId);
Assert.AreEqual(fieldDefinition2.FieldId, result.Value.Fields[1].CardFieldDefinition.FieldId);
//Card of other user -> unauthorized
result = await controller.GetAsync(2);
Assert.IsTrue(result.Result is UnauthorizedResult);
//Card does not exist -> not found
result = await controller.GetAsync(3);
Assert.IsTrue(result.Result is NotFoundResult);
}
public void PostCardPassed()
{
// Arrange
var mock = new Mock <IBankRepository>();
var mockCards = new FakeDataGenerator(_businessLogicService).GenerateFakeCards();
var cardDto = new CardDto
{
Name = "my card",
Currency = 0,
Type = 1
};
var mockCard = new FakeDataGenerator(_businessLogicService).GenerateFakeCard(cardDto);
mock.Setup(r => r.GetCards()).Returns(mockCards);
mock.Setup(r => r.OpenNewCard(It.IsAny <string>(), It.IsAny <Currency>(), It.IsAny <CardType>())).Returns(mockCard);
var controller = new CardsController(mock.Object, _cardService, _businessLogicService);
// Test
var result = (CreatedResult)controller.Post(cardDto);
var resultCard = (CardDto)result.Value;
// Assert
mock.Verify(r => r.GetCards(), Times.AtMostOnce());
mock.Verify(r => r.OpenNewCard(It.IsAny <string>(), It.IsAny <Currency>(), It.IsAny <CardType>()), Times.AtMostOnce());
Assert.Equal(201, result.StatusCode);
Assert.Equal(0, resultCard.Balance);
Assert.Equal(cardDto.Name, resultCard.Name);
Assert.NotNull(resultCard.Number);
Assert.Equal(cardDto.Currency, resultCard.Currency);
Assert.Equal(cardDto.Type, resultCard.Type);
}
public async Task UpdateCard_UnknownIdPassed_ReturnsNotFound()
{
// Arrange
var controller = new CardsController(flashcardDbContextMock.Object, logger);
int unknownId = 15;
var rightCard = new CardDTO
{
Id = 15,
Type = "Teszt tipus update",
Card_number = 3,
Question_text = "Teszt kartya kerdes",
Question_picture = "kep.jpg",
Answer_text = "Teszt kartya valasz",
Answer_picture = "kep2.jpg",
Deck = new DeckInfoDTO
{
Id = 1,
Name = "Teszt csomag",
Module = Module.A,
Deck_number = 1,
Status = DeckStatus.Approved
}
};
// Act
var result = await controller.UpdateCard(unknownId, rightCard);
// Asssert
Assert.IsType <NotFoundResult>(result);
}
public void UpdateCard()
{
var context = serviceProvider.GetRequiredService <DataContext>();
var controller = new CardsController(context);
context.Card.Add(card1);
context.SaveChanges();
//The entity is not being tracked by the context
context.Entry(card1).State = EntityState.Detached;
Card card3 = new Card
{
Id = 1,
Number = "8813582836371494",
ExpirationDate = new DateTime(2022, 09, 09),
PinCode = "9913",
CvvCode = "697",
OwnerId = "1",
BankName = "BRD",
BankAccountId = "91875712"
};
var updateResult = controller.PutCard(1, card3).Result;
Assert.IsType <OkResult>(updateResult);
}
public async Task UpdateCardFromDeckById_Method_Returns_NotFound_DeckExist_CardNotExist()
{
//Arrange
var mockRepository = new Mock <IFlashcardDataRepository>();
mockRepository.Setup(x => x.isDeckExist(1)).Returns((int id) => Task.FromResult(true));
mockRepository.Setup(x => x.UpdateCardFromDeckByCardId(1, 1, "q1", "a1"))
.Returns((int id, int cardId, string questionText, string answerText) => Task.FromResult(false));
CardsController cardsController = new CardsController(mockRepository.Object, iMapper);
Card card = new Card()
{
Id = 1,
DeckId = 1,
QuestionText = "q1",
AnswerText = "a1"
};
//Act
var result = await cardsController.UpdateCardFromDeckById(1, 1, card);
//Assert
var notFoundObjectResult = Assert.IsType <NotFoundObjectResult>(result);
var errorResponse = Assert.IsType <ErrorResponse>(notFoundObjectResult.Value);
Assert.Equal("Card with Id 1 not found", errorResponse.Errors[0]);
}
// Use this for initialization
void Start()
{
GameObject CardsObjs = GameObject.Find("Cards");
cardsScript = CardsObjs.GetComponent <CardsController> ();
Score = GetComponent <Text> ();
}
public CardControllerTests()
{
optionsBuilder = new DbContextOptionsBuilder <FlashcardContext>();
optionsBuilder.UseInMemoryDatabase("UnitTestMemoryDB");
dbContext = new FlashcardContext(optionsBuilder.Options);
cardsController = new CardsController(dbContext);
}
public void DeleteCard405()
{
var mock = new Mock <IBankRepository>();
var controller = new CardsController(mock.Object, _cardService, _businessLogicService);
var result = (StatusCodeResult)controller.Delete();
Assert.Equal(405, result.StatusCode);
}
public async Task Post_ShouldReturnNotFound()
{
var cardsService = new Mock <ICardsService>();
var controller = new CardsController(cardsService.Object);
// Act
IHttpActionResult actionResult = await controller.Post(null);
Assert.IsInstanceOfType(actionResult, typeof(InvalidModelStateResult));
}
public void GetById()
{
// Arrange
CardsController controller = new CardsController();
// Act
string result = controller.Get(5);
// Assert
Assert.AreEqual("value", result);
}
public async Task PutCardTest()
{
using DbContext context = CreateContext();
CardsController controller = CreateController(context);
//null as parameter -> bad request
ActionResult <Card> result = await controller.PutAsync(null);
Assert.IsTrue(result.Result is BadRequestResult);
//card does not exist in db -> not found
Card newCard = new Card()
{
CardId = 5,
DeckId = deck.DeckId,
CardTemplateId = template.CardTemplateId
};
newCard.Fields.Add(new CardField()
{
FieldId = 1, FieldName = "test1", Value = "test1"
});
newCard.Fields.Add(new CardField()
{
FieldId = 2, FieldName = "test2", Value = "test2"
});
result = await controller.PutAsync(newCard);
Assert.IsTrue(result.Result is NotFoundResult);
//Save changed entity
card.Tags = "test";
result = await controller.PutAsync(card);
Assert.IsNotNull(result.Value);
Card card1 = context.Find <Card>(card.CardId);
Assert.AreEqual("test", card1.Tags);
Assert.AreEqual(2, card1.Fields.Count);
Assert.AreEqual(field1.FieldName, card1.Fields[0].FieldName);
//Invalid card is validated
bool wasThrown = false;
try
{
result = await controller.PostAsync(new Card());
}
catch (NotifyException)
{
wasThrown = true;
}
Assert.IsTrue(wasThrown);
}
public void Dispose()
{
optionsBuilder = null;
foreach (var card in dbContext.Cards)
{
dbContext.Cards.Remove(card);
}
dbContext.SaveChanges();
dbContext.Dispose();
cardsController = null;
}
public async Task GetCard_UnknownIdPassed_ReturnsNotFoundResult()
{
// Arrange
var controller = new CardsController(flashcardDbContextMock.Object, logger);
int unknownCardId = 5;
// Act
var result = await controller.GetCard(unknownCardId);
// Asssert
Assert.IsType <NotFoundResult>(result.Result);
}
public async Task GetCard_ExistingIdPassed_ReturnsRightCard()
{
// Arrange
var controller = new CardsController(flashcardDbContextMock.Object, logger);
int existingCardId = 2;
// Act
var result = await controller.GetCard(existingCardId);
// Asssert
Assert.Equal(2, result.Value.Id);
}
public async Task DeleteCardPicture_UnknownIdPassed_ReturnsNotFound()
{
// Arrange
var controller = new CardsController(flashcardDbContextMock.Object, logger);
int unknownId = 22;
// Act
var result = await controller.DeleteCardPicture(unknownId, "question");
// Asssert
Assert.IsType <NotFoundResult>(result);
}
public void GetByIdCard_ShouldReturnCardById()
{
var context = serviceProvider.GetRequiredService <DataContext>();
var controller = new CardsController(context);
context.Card.Add(card1);
var card = controller.GetCardById(1).Result.Value;
Assert.Equal(card, card1);
}
public void CreateCard()
{
var context = serviceProvider.GetRequiredService <DataContext>();
var controller = new CardsController(context);
controller.PostCard(card1);
var createdCard = controller.GetCardById(card1.Id).Result.Value;
Assert.Equal(createdCard, card1);
}
public void Picked()
{
GameObject CardsObjs = GameObject.Find("Cards");
cardsScript = CardsObjs.GetComponent <CardsController> ();
if (!IsAnimating && cardsScript.CardsUp < 2 && !IsFaceUp)
{
IsFaceUp = !IsFaceUp;
ChangeTexture();
}
}
public void SetUp()
{
if (!_mapperIntialized)
{
Mapper.Initialize(cfg => {
cfg.AddProfile <MappingProfile>();
});
_mapperIntialized = true;
}
_unitOfWork = new Mock <IUnitOfWork>();
_cardsController = new CardsController(_unitOfWork.Object);
}
public async Task Details_VerifyOnce()
{
//Arrange
var WalletId = 1;
var mockCard = new Mock <ICardService>();
var controller = new CardsController(mockCard.Object);
//Act
var result = await controller.Details(1) as OkObjectResult;
//Assert
mockCard.Verify(a => a.GetAsync(WalletId), Times.Once);
}
public async Task GetCards_ReturnsAllCards()
{
// Arrange
var controller = new CardsController(flashcardDbContextMock.Object, logger);
// Act
var result = await controller.GetCards();
// Asssert
var cards = Assert.IsType <List <CardDTO> >(result.Value);
Assert.Equal(2, cards.Count);
}
public void DeleteCard_ShouldRedirectToActionDelete()
{
//Arrange
var mockCard = new Mock <ICardService>();
var controller = new CardsController(mockCard.Object);
//Act
var result = controller.RedirectToAction("Delete");
//Assert
Assert.That(result.ActionName, Is.EqualTo("Delete"));
}
public MainWindow()
{
CreateComponents();
lessonsController = new CoursesController(
coursesView,
btnAddSubject,
btnAddLesson);
cardsController = new CardsController(
tableCards,
btnAddCard,
showHiddenCards,
showCompletedCards,
cardMenu,
lessonsController);
}
private static void Arrange() {
_client = new Mock<ICardsClient>();
_controller = new CardsController(_client.Object);
}
