public void IndexReturnsAViewResultWithALists()
{
Tournament _cup = new Tournament();
_cup.Name = "English premier league";
_cup.MaxCountTeams = 18;
_cup.TournamentId = 1;
_cup.StartDate = "01.10.2017";
_cup.EndDate = "08.08.2018";
_cup.Password = "******";
_cup.Mail = "*****@*****.**";
// Arrange
var mockHighService = new Mock <IHighLevelSoccerManagerService>();
mockHighService.Setup(service => service.GetAllTournaments()).Returns(new List <Tournament>()
{
_cup
});
mockHighService.Setup(service => service.GetTeam(It.IsAny <int>())).Returns(new Team()
{
Name = "team", TeamId = 1
});
var store = new Mock <IUserStore <User> >();
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserRoleStore = mockUserStore.As <IUserRoleStore <User> >();
var userManager = new Mock <UserManager <User> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
userManager.Setup(u => u.GetUserAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(
new User()
{
UserName = "******",
UserId = 1
});
OrganizerController controller = new OrganizerController(mockHighService.Object, userManager.Object, null);
controller.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, "Test")
}))
}
};
// Act
ViewResult result = (ViewResult)controller.Index(1).Result;
Team selectedTeam = controller.SelectedTeam;
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
Assert.Equal(_cup, ((OrganaizerMainInfo)viewResult?.Model).Tournament);
Assert.Equal("team", ((OrganaizerMainInfo)viewResult?.Model).SelectedTeam.Name);
Assert.False(((OrganaizerMainInfo)viewResult?.Model).ShowConfirming);
Assert.Equal(1, selectedTeam.TeamId);
Assert.Equal("team", selectedTeam.Name);
}
public async void RemoveTeamTest()
{
var testTeam = this.GetTestCups();
var mockHighService = new Mock <IHighLevelSoccerManagerService>();
mockHighService.Setup(service => service.RemoveTeamFromTournament(It.IsAny <int>(), It.IsAny <int>())).Callback <int, int>(
(a, b) =>
{
foreach (var team in testTeam)
{
if (team.TournamentId == b)
{
team.TeamTournaments.RemoveAll(e => e.TeamId == a);
}
}
});
mockHighService.Setup(service => service.GetAllTournaments()).Returns(testTeam);
mockHighService.Setup(service => service.GetTeam(It.IsAny <int>())).Returns <int>(a =>
{
return(new Team()
{
Name = "Name"
});
});
var store = new Mock <IUserStore <User> >();
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserRoleStore = mockUserStore.As <IUserRoleStore <User> >();
var userManager = new Mock <UserManager <User> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
userManager.Setup(u => u.GetUserAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(
new User()
{
UserName = "******",
UserId = 1
});
OrganizerController controller = new OrganizerController(mockHighService.Object, userManager.Object, null);
controller.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, "Test")
}))
}
};
var result = await controller.RemoveTeam(2);
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <OrganaizerMainInfo>(viewResult.Model);
Assert.Empty(model.Tournament.TeamTournaments.Where(el => el.TeamId == 2));
Assert.Single(model.Tournament.TeamTournaments);
Assert.Equal(3, model.Tournament.TeamTournaments.Find(el => el.TournamentId == 1).TeamId);
}
public async Task ShouldGetOrganizerById()
{
CreateOrganizers();
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
ActionResult <OrganizerVm> result1 = await organizerController.GetOrganizerAsync(1);
OrganizerVm returnedOrganizer1 = result1.Value;
Assert.AreEqual(1, returnedOrganizer1.Id);
Assert.AreEqual("Organizer 1", returnedOrganizer1.Name);
Assert.AreEqual("123456", returnedOrganizer1.OrgNumber);
Assert.AreEqual("Description", returnedOrganizer1.Description);
ActionResult <OrganizerVm> result2 = await organizerController.GetOrganizerAsync(2);
OrganizerVm returnedOrganizer2 = result2.Value;
Assert.AreEqual(2, returnedOrganizer2.Id);
Assert.AreEqual(_orgName1, returnedOrganizer2.Name);
Assert.AreEqual(_orgNummer1, returnedOrganizer2.OrgNumber);
Assert.AreEqual(_decsr1, returnedOrganizer2.Description);
}
public void TestTempLogin()
{
// Arrange
var request = new TemporaryLoginRequest(TEST_TOKEN, TEST_EMAIL);
var expectedResponse = new Response <TxSessionCredentials>(CREDENTIALS);
var mockClient = new Mock <IOrganizerClient>();
mockClient.Setup(client => client.TemporaryLogin(request))
.Returns(expectedResponse.WithSuccess());
// Act
var organizerController = new OrganizerController(
requestFieldExtractor,
mockClient.Object);
var result = organizerController.TempLogin(request) as OkObjectResult;
var response = result.Value as Response <TxSessionCredentials>;
// Assert
Assert.NotNull(response);
Assert.True(response.IsSuccessStatusCode);
Assert.False(response.Payload.IsAdmin);
Assert.Equal(expectedResponse.Payload, response.Payload);
}
public void TestGrantAccessToken()
{
// Arrange
var request = new GenerateTemporaryOrganizerRequest(TEST_TOURNAMENT_ID, TEST_NAME, TEST_EMAIL);
var expectedPayload = new GetAccessTokenResponse();
expectedPayload.Token = TEST_TOKEN;
var expectedResponse = new Response <GetAccessTokenResponse>(expectedPayload);
var mockClient = new Mock <IOrganizerClient>();
mockClient.Setup(client => client.GenerateTemporaryOrganizer(CREDENTIALS, request))
.Returns(expectedResponse.WithSuccess());
// Act
var organizerController = new OrganizerController(
requestFieldExtractor,
mockClient.Object);
var result = organizerController.GrantAccessToken(request) as OkObjectResult;
var response = result.Value as Response <GetAccessTokenResponse>;
// Assert
Assert.NotNull(response);
Assert.True(response.IsSuccessStatusCode);
Assert.Equal(expectedResponse.Payload, response.Payload);
}
public void ShouldNotGetOrganizerByIdIfDoesntExist()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
var ex = Assert.ThrowsAsync <HttpException>(async() =>
{
ActionResult <OrganizerVm> result1 = await organizerController.GetOrganizerAsync(123);
});
Assert.That(ex.Message == "Fant ingen arrangører med id: 123");
}
public async Task ShoulSetOrganizerContact()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
ActionResult <OrganizerVm> contact = await organizerController.SetOrganizerContactAsync(1, _user1.Entity.Id);
Organizer org1 = _dbContext.Organizers.Find(1);
Assert.AreEqual(_user1.Entity.Id, org1.ContactId);
}
public async Task ShouldGetAdmins()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
ActionResult <List <OrgAdminVm> > result = await organizerController.GetOrgAdminsAsync(3);
List <OrgAdminVm> returnedAdmins = (List <OrgAdminVm>)((OkObjectResult)result.Result).Value;
Assert.AreEqual(_user2.Entity.Id, returnedAdmins[0].Id);
}
public async Task ShouldGetOrganizerContact()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
ActionResult <List <OrganizerVm> > result = await organizerController.GetOrganizerContactAsync(2);
List <OrganizerVm> returnedContacts = (List <OrganizerVm>)((OkObjectResult)result.Result).Value;
Assert.AreEqual(1, returnedContacts.Count);
Assert.AreEqual("Test Testesen", returnedContacts[0].ContactName);
Assert.AreEqual(_orgNummer1, returnedContacts[0].OrgNumber);
}
public void ShouldNotCreateOrganizerIfAlreadyExists()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
var ex = Assert.ThrowsAsync <HttpException>(async() =>
{
await organizerController.CreateOrganizerAsync(new OrganizerVm {
Id = 2, Name = _orgName1, OrgNumber = _orgNummer1, Description = _decsr1
});
});
Assert.That(ex.Message == "Arrangøren: Org 2 eksisterer allerede");
}
public void ShouldNotUpdateOrganizerWithInvalidId()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
var ex = Assert.ThrowsAsync <HttpException>(async() =>
{
await organizerController.UpdateOrganizerAsync(new OrganizerVm {
Id = 123, Name = _orgName1, OrgNumber = _orgNummer1, Description = _decsr1
});
});
Assert.That(ex.Message == "Fant ikke arrangøren");
}
public async Task ShouldGetOrgsWhereUserIsAdmin()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
SetUser(organizerController, _user2.Entity.Id);
ActionResult <List <OrganizerListVm> > org = await organizerController.GetOrgsWhereUserIsAdminAsync();
List <OrganizerListVm> returnedOrgs = (List <OrganizerListVm>)((OkObjectResult)org.Result).Value;
Assert.AreEqual(3, returnedOrgs[0].Id);
Assert.AreEqual(_orgName2, returnedOrgs[0].Name);
Assert.AreEqual(_orgNummer2, returnedOrgs[0].OrgNumber);
}
public async Task ShoulRemoveOrgAdmin()
{
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
await organizerController.RemoveOrgAdminAsync(3, _user2.Entity.Id);
Organizer org = _dbContext.Organizers.Find(3);
// Check that Organizer nas no admins
Assert.IsFalse(org.Admins.Contains(_user2.Entity));
Assert.IsFalse(org.Admins.Contains(_user1.Entity));
Assert.IsFalse(org.Admins.Contains(_createdUser1.Entity));
Assert.IsFalse(org.Admins.Contains(_createdUser2.Entity));
}
public async Task ShouldSetOrgAdmin()
{
UserStore <ApplicationUser> store = new UserStore <ApplicationUser>(_dbContext);
UserManager <ApplicationUser> userManager = new UserManager <ApplicationUser>(store, null, new PasswordHasher <ApplicationUser>(), null, null, null, null, null, null);
OrganizerService organizerService = new OrganizerService(_dbContext, userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
CreateOrganizers();
await organizerController.SetOrgAdminAsync(3, _user1.Entity.Id);
// Check that Admins contains only _user1 and do not contain _createdUser
Organizer org = _dbContext.Organizers.Find(3);
Assert.That(org.Admins.Contains(_user1.Entity));
Assert.IsFalse(org.Admins.Contains(_createdUser1.Entity));
}
public async Task ShouldUpdateOrganizer()
{
CreateOrganizers();
string newName = "Org 4";
string newOrgNummer = "4";
string decsr = "Org Descr 4";
EntityEntry <ApplicationUser> user4 = _dbContext.ApplicationUsers.Add(
new ApplicationUser
{
FirstName = "Test",
MiddleName = "",
LastName = "Testesen",
Address = "Testing gate 123",
DateOfBirth = DateTime.Now,
IsAllergic = false
}
);
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
OrganizerVm organizerVm = new OrganizerVm {
Id = 2, Name = newName, OrgNumber = newOrgNummer, Description = decsr, ContactName = user4.Entity.Id
};
await organizerController.UpdateOrganizerAsync(organizerVm);
// Check that only one has been changed
Organizer organizer1 = _dbContext.Organizers.Find(2);
Assert.AreEqual(newName, organizer1.Name);
Assert.AreEqual(newOrgNummer, organizer1.OrgNumber);
Assert.AreEqual(decsr, organizer1.Description);
Assert.AreEqual(user4.Entity.Id, organizer1.ContactId);
Organizer organizer2 = _dbContext.Organizers.Find(1);
Assert.AreEqual("Organizer 1", organizer2.Name);
Assert.AreEqual("123456", organizer2.OrgNumber);
Assert.AreEqual("Description", organizer2.Description);
}
public async Task ShouldGetOrganizers()
{
CreateOrganizers();
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
SetUser(organizerController, _createdUser1.Entity.Id);
ActionResult <List <OrganizerListVm> > result = await organizerController.GetOrganizersAsync();
List <OrganizerListVm> returnedOrganizers = result.Value;
Assert.AreEqual(3, returnedOrganizers.Count);
Assert.AreEqual(1, returnedOrganizers[0].Id);
Assert.AreEqual("Organizer 1", returnedOrganizers[0].Name);
Assert.AreEqual("123456", returnedOrganizers[0].OrgNumber);
Assert.AreEqual(2, returnedOrganizers[1].Id);
Assert.AreEqual(_orgName1, returnedOrganizers[1].Name);
Assert.AreEqual(_orgNummer1, returnedOrganizers[1].OrgNumber);
}
public async Task ShouldCreateOrganizer()
{
CreateOrganizers();
string orgName = "Org 5";
string orgNummer = "56322";
string decsr = "Org Descr 5";
EntityEntry <ApplicationUser> user = _dbContext.ApplicationUsers.Add(
new ApplicationUser
{
FirstName = "Test",
MiddleName = "",
LastName = "Testesen",
Address = "Testing gate 123",
DateOfBirth = DateTime.Now,
IsAllergic = false
}
);
OrganizerService organizerService = new OrganizerService(_dbContext, _userManager);
OrganizerController organizerController = new OrganizerController(organizerService);
OrganizerVm organizerVm = new OrganizerVm {
Name = orgName, OrgNumber = orgNummer, Description = decsr, ContactName = user.Entity.Id
};
await organizerController.CreateOrganizerAsync(organizerVm);
ActionResult <List <OrganizerListVm> > organizers = await organizerController.GetOrganizersAsync();
List <OrganizerListVm> returnedOrganizers = organizers.Value;
Organizer newOrganizer = _dbContext.Organizers.Find(4);
Assert.That(returnedOrganizers, Has.Exactly(1).Matches <OrganizerListVm>(organizer => organizer.Id == newOrganizer.Id &&
organizer.Name == newOrganizer.Name &&
organizer.OrgNumber == newOrganizer.OrgNumber
));
}
public OrganizerWin(IBaseWindow baseWin)
{
InitializeComponent();
fBase = baseWin;
fAdrList = new GKSheetList(pageAddresses);
fAdrList.Buttons = EnumSet <SheetButton> .Create();
fAdrList.AddColumn(LangMan.LS(LSID.LSID_Person), 350, false);
fAdrList.AddColumn(LangMan.LS(LSID.LSID_Address), 100, false);
fPhonesList = new GKSheetList(pageTelephones);
fPhonesList.Buttons = EnumSet <SheetButton> .Create();
fPhonesList.AddColumn(LangMan.LS(LSID.LSID_Person), 350, false);
fPhonesList.AddColumn(LangMan.LS(LSID.LSID_Telephone), 100, false);
fMailsList = new GKSheetList(pageMails);
fMailsList.Buttons = EnumSet <SheetButton> .Create();
fMailsList.AddColumn(LangMan.LS(LSID.LSID_Person), 350, false);
fMailsList.AddColumn(LangMan.LS(LSID.LSID_Mail), 100, false);
fWebsList = new GKSheetList(pageWebs);
fWebsList.Buttons = EnumSet <SheetButton> .Create();
fWebsList.AddColumn(LangMan.LS(LSID.LSID_Person), 350, false);
fWebsList.AddColumn(LangMan.LS(LSID.LSID_WebSite), 100, false);
Title = LangMan.LS(LSID.LSID_MIOrganizer);
pageAddresses.Text = LangMan.LS(LSID.LSID_Addresses);
pageTelephones.Text = LangMan.LS(LSID.LSID_Telephones);
pageMails.Text = LangMan.LS(LSID.LSID_Mails);
pageWebs.Text = LangMan.LS(LSID.LSID_Webs);
fController = new OrganizerController(this);
fController.Init(baseWin);
}
public async void ConfirmTest()
{
var testCup = new Tournament()
{
Name = "APL",
Mail = "*****@*****.**",
TournamentId = 1,
Password = "******",
MaxCountTeams = 10,
EndDate = "end",
StartDate = "start"
};
var updatedCup = new Tournament()
{
Name = "UAPL",
Mail = "*****@*****.**",
TournamentId = 1,
Password = "******",
MaxCountTeams = 100,
EndDate = "Uend",
StartDate = "Ustart"
};
var mockHighService = new Mock <IHighLevelSoccerManagerService>();
mockHighService.Setup(service => service.UpdateTournament(It.IsAny <int>(), It.IsAny <Tournament>())).Callback <int, Tournament>(
(a, b) =>
{
testCup = b;
});
mockHighService.Setup(service => service.GetAllTournaments()).Returns(new List <Tournament>()
{
testCup
});
mockHighService.Setup(service => service.GetTeam(It.IsAny <int>())).Returns <int>(a =>
{
return(new Team()
{
Name = "Name"
});
});
var store = new Mock <IUserStore <User> >();
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserRoleStore = mockUserStore.As <IUserRoleStore <User> >();
var userManager = new Mock <UserManager <User> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
userManager.Setup(u => u.GetUserAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(
new User()
{
UserName = "******",
UserId = 1
});
OrganizerController controller = new OrganizerController(mockHighService.Object, userManager.Object, null);
controller.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, "Test")
}))
}
};
var result = await controller.Confirm();
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <OrganaizerMainInfo>(viewResult.Model);
Assert.Equal(model.Tournament.Name, testCup.Name);
Assert.Equal(model.Tournament.MaxCountTeams, testCup.MaxCountTeams);
Assert.Equal(model.Tournament.Mail, testCup.Mail);
Assert.Equal(model.Tournament.EndDate, testCup.EndDate);
Assert.Equal(model.Tournament.StartDate, testCup.StartDate);
Assert.Equal(model.Tournament.Password, testCup.Password);
}
public async void DeleteTest()
{
Tournament cup1 = new Tournament();
cup1.Name = "English premier league";
cup1.MaxCountTeams = 18;
cup1.TournamentId = 1;
cup1.StartDate = "01.10.2017";
cup1.EndDate = "08.08.2018";
cup1.Password = "******";
cup1.Mail = "*****@*****.**";
Tournament cup2 = new Tournament()
{
Name = "New",
Mail = "*****@*****.**",
StartDate = "01-01-2018",
EndDate = "01-01-2019",
MaxCountTeams = 40
};
cup2.TournamentId = 2;
List <Tournament> lst = new List <Tournament>()
{
cup1, cup2
};
// Arrange
var mockHighService = new Mock <IHighLevelSoccerManagerService>();
mockHighService.Setup(service => service.GetAllTournaments()).Returns(lst);
mockHighService.Setup(ser => ser.RemoveTournament(It.IsAny <int>())).Callback(() =>
{
lst.RemoveAt(0);
});
var store = new Mock <IUserStore <User> >();
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserRoleStore = mockUserStore.As <IUserRoleStore <User> >();
var userManager = new Mock <UserManager <User> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
userManager.Setup(u => u.GetUserAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(
new User()
{
UserName = "******",
UserId = 1
});
OrganizerController controller = new OrganizerController(mockHighService.Object, userManager.Object, null);
controller.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, "Test")
}))
}
};
// Act
var result = await controller.Delete();
// Assert
var viewResult = Assert.IsType <RedirectToActionResult>(result);
Assert.Single(lst);
}
public void SelectTest()
{
Tournament cup1 = new Tournament();
cup1.Name = "English premier league";
cup1.MaxCountTeams = 18;
cup1.TournamentId = 1;
cup1.StartDate = "01.10.2017";
cup1.EndDate = "08.08.2018";
cup1.Password = "******";
cup1.Mail = "*****@*****.**";
Tournament cup2 = new Tournament()
{
Name = "New",
Mail = "*****@*****.**",
StartDate = "01-01-2018",
EndDate = "01-01-2019",
MaxCountTeams = 40
};
// Arrange
var mockHighService = new Mock <IHighLevelSoccerManagerService>();
mockHighService.Setup(service => service.GetAllTournaments()).Returns(new List <Tournament>()
{
cup1
});
mockHighService.Setup(ser => ser.GetAllTeam()).Returns(GetTestTeams());
mockHighService.Setup(ser => ser.GetTeam(It.IsAny <int>())).Returns(GetTestTeams().First());
var store = new Mock <IUserStore <User> >();
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserRoleStore = mockUserStore.As <IUserRoleStore <User> >();
var userManager = new Mock <UserManager <User> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
userManager.Setup(u => u.GetUserAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(
new User()
{
UserName = "******",
UserId = 1
});
OrganizerController controller = new OrganizerController(mockHighService.Object, userManager.Object, null);
controller.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, "Test")
}))
}
};
controller.ModelState.AddModelError("Name", "Required");
// Act
ViewResult result = (ViewResult)controller.SelectDate("1900", 1).Result;
// Assert
var viewResult = Assert.IsType <ViewResult>(result);
var model = Assert.IsAssignableFrom <OrganaizerMainInfo>(viewResult.Model);
Assert.Equal(3, model.Teams.Count);
Assert.Equal(2, model.SelectedTeams.Count);
Assert.Equal(GetTestTeams().First().TeamId, model.SelectedTeam.TeamId);
}
public void EditCupReturnsViewResultWithCupModel()
{
Tournament old_cup = new Tournament();
old_cup.Name = "English premier league";
old_cup.MaxCountTeams = 18;
old_cup.TournamentId = 1;
old_cup.StartDate = "01.10.2017";
old_cup.EndDate = "08.08.2018";
old_cup.Password = "******";
old_cup.Mail = "*****@*****.**";
Tournament new_cup = new Tournament()
{
Name = "New",
Mail = "*****@*****.**",
StartDate = "01-01-2018",
EndDate = "01-01-2019",
MaxCountTeams = 40
};
// Arrange
var mockHighService = new Mock <IHighLevelSoccerManagerService>();
mockHighService.Setup(service => service.GetAllTournaments()).Returns(new List <Tournament>()
{
old_cup
});
mockHighService.Setup(service => service.UpdateTournament(It.IsAny <int>(), It.IsAny <Tournament>()))
.Callback(() =>
{
old_cup = new_cup;
});
var store = new Mock <IUserStore <User> >();
var mockUserStore = new Mock <IUserStore <User> >();
var mockUserRoleStore = mockUserStore.As <IUserRoleStore <User> >();
var userManager = new Mock <UserManager <User> >(mockUserStore.Object, null, null, null, null, null, null, null, null);
userManager.Setup(u => u.GetUserAsync(It.IsAny <ClaimsPrincipal>())).ReturnsAsync(
new User()
{
UserName = "******",
UserId = 1
});
OrganizerController controller = new OrganizerController(mockHighService.Object, userManager.Object, null);
controller.ControllerContext = new ControllerContext
{
HttpContext = new DefaultHttpContext
{
User = new ClaimsPrincipal(new ClaimsIdentity(new Claim[]
{
new Claim(ClaimTypes.Name, "Test")
}))
}
};
controller.ModelState.AddModelError("Name", "Required");
// Act
RedirectToActionResult result = (RedirectToActionResult)controller.Edit(new_cup).Result;
// Assert
var viewResult = Assert.IsType <RedirectToActionResult>(result);
}