public void EditPost_Returns_Journals()
{
Mapper.CreateMap <JournalUpdateViewModel, Journal>();
//Arrange
var membershipRepository = Mock.Create <IStaticMembershipService>();
var journalRepository = Mock.Create <IJournalRepository>();
Mock.Arrange(() => journalRepository.UpdateJournal(null)).IgnoreArguments().Returns(
new OperationStatus()
{
Status = true
}).MustBeCalled();
//Act
PublisherController controller = new PublisherController(journalRepository, membershipRepository);
ActionResult actionResult = controller.Edit(new JournalUpdateViewModel()
{
ContentType = "pdf",
Content = new byte[1],
Description = "abc",
Id = 1
});
//Assert
Assert.IsNotNull(actionResult);
}
public void SetUp()
{
_publisherService = A.Fake <IPublisherService>();
_logger = A.Fake <ILogger <PublisherController> >();
_mapper = A.Fake <IMapper>();
_publisherController = new PublisherController(_publisherService, _logger, _mapper);
}
public void GetFile_Returns_Journals()
{
Mapper.CreateMap <Journal, JournalViewModel>();
//Arrange
var membershipRepository = Mock.Create <IStaticMembershipService>();
var userMock = Mock.Create <MembershipUser>();
Mock.Arrange(() => userMock.ProviderUserKey).Returns(1);
Mock.Arrange(() => membershipRepository.GetUser()).Returns(userMock);
var journalRepository = Mock.Create <IJournalRepository>();
Mock.Arrange(() => journalRepository.GetJournalById(1)).Returns(
new Journal {
Id = 1, Description = "TestDesc", FileName = "TestFilename.pdf", Title = "Tester", UserId = 1, ModifiedDate = DateTime.Now, Content = new byte[] {}, ContentType = "pdf"
}).MustBeCalled();
//Act
PublisherController controller = new PublisherController(journalRepository, membershipRepository);
FileContentResult actionResult = (FileContentResult)controller.GetFile(1);
//Assert
Assert.IsNotNull(actionResult);
}
public PublisherInterface()
{
controller = new PublisherController();
userCommands = new Dictionary <string, Action>()
{
{ "list blocks", ListBlocks }
, { "list nodes", ListNodes }
, { "list transactions", ListTransactions }
, { "list patients", ListPatients }
, { "list physicians proposed", ListPhysiciansProposed }
, { "list physicians", ListPhysicians }
, { "list publishers proposed", ListPublishersProposed }
, { "list publishers", ListPublishers }
, { "load chain", LoadChain }
, { "ping node", PingNode }
, { "save chain", SaveChain }
, { "server reset address", ResetServerAddress }
, { "server stats address", DisplayServerAddress }
, { "test transactions", GenerateTestTransactions }
, { "validate chain", ValidateChain }
, { "vote physician", VotePhysician }
, { "vote publisher", VotePublisher }
};
}
public void Edit_Returns_Journals()
{
Mapper.CreateMap <Journal, JournalUpdateViewModel>();
//Arrange
var membershipRepository = Mock.Create <IStaticMembershipService>();
var journalRepository = Mock.Create <IJournalRepository>();
Mock.Arrange(() => journalRepository.GetJournalById(1)).IgnoreArguments().Returns(
new Journal
{
Id = 1,
Description = "TestDesc",
FileName = "TestFilename.pdf",
Title = "Tester",
UserId = 1,
ModifiedDate = DateTime.Now,
Content = new byte[] { },
ContentType = "pdf"
}).MustBeCalled();
//Act
PublisherController controller = new PublisherController(journalRepository, membershipRepository);
ActionResult actionResult = controller.Edit(1);
//Assert
Assert.IsNotNull(actionResult);
}
public void Index_Returns_All_Journals()
{
Mapper.CreateMap <Journal, JournalViewModel>();
//Arrange
var membershipRepository = Mock.Create <IStaticMembershipService>();
var userMock = Mock.Create <MembershipUser>();
Mock.Arrange(() => userMock.ProviderUserKey).Returns(1);
Mock.Arrange(() => membershipRepository.GetUser()).Returns(userMock);
var journalRepository = Mock.Create <IJournalRepository>();
Mock.Arrange(() => journalRepository.GetAllJournals((int)userMock.ProviderUserKey)).Returns(new List <Journal>()
{
new Journal {
Id = 1, Description = "TestDesc", FileName = "TestFilename.pdf", Title = "Tester", UserId = 1, ModifiedDate = DateTime.Now
},
new Journal {
Id = 1, Description = "TestDesc2", FileName = "TestFilename2.pdf", Title = "Tester2", UserId = 1, ModifiedDate = DateTime.Now
}
}).MustBeCalled();
//Act
PublisherController controller = new PublisherController(journalRepository, membershipRepository);
ViewResult actionResult = (ViewResult)controller.Index();
var model = actionResult.Model as IEnumerable <JournalViewModel>;
//Assert
Assert.AreEqual(2, model.Count());
}
public void TestIndexPublisher()
{
var controller = new PublisherController();
var result = controller.Index(1);
Assert.IsNotNull(result);
}
private static void StartPublisherForm(object ipAndPort)
{
PublisherController publisherController = new PublisherController((string)ipAndPort);
PublisherGUI publisherGUI = new PublisherGUI(publisherController);
Application.Run(publisherGUI);
}
public frmAddBook()
{
InitializeComponent();
_bookController = new BookController();
_authorController = new AuthorController();
_publisherController = new PublisherController();
currentBook = new Book();
}
public void CreateMethodShouldReturnActionResult()
{
var service = new PublisherController(_managerMock.Object);
var res = service.CreatePublisher() as ViewResult;
Assert.AreEqual("CreatePublisherForm", res.ViewName);
}
public PublisherControllerTest()
{
_mapper = MapperConfigUi.GetMapper().CreateMapper();
_publisherService = new Mock <IPublisherService>();
_userService = new Mock <IUserService>();
_sut = new PublisherController(_publisherService.Object, _userService.Object, _mapper, null);
_fakePublisherName = "test";
}
public void CreatePostMethodShouldReturnActionResult()
{
var service = new PublisherController(_managerMock.Object);
var res = service.CreatePublisher(new CreatePublisherViewModel {
CompanyName = "ssss", Description = "ssssss", HomePage = "www.asd.com"
}) as RedirectToRouteResult;
Assert.AreEqual(true, res.RouteValues.ContainsValue("GetAllGames"));
}
public void ShouldReturnCorrectView()
{
var service = new PublisherController(_managerMock.Object);
_managerMock.Setup(x => x.Find(It.IsAny <Expression <Func <Publisher, bool> > >()))
.Returns(new List <Publisher> {
new Publisher()
});
var result = service.PublisherDetails("name") as ViewResult;
Assert.AreEqual("PublisherDetails", result.ViewName);
}
private static PublisherController GetPublisherController(
IMock <IPublisherService> mockPublisherService = null,
IMock <ILanguageService> mockLanguageService = null
)
{
mockPublisherService = mockPublisherService ?? new Mock <IPublisherService>();
mockLanguageService = mockLanguageService ?? new Mock <ILanguageService>();
var publisherController = new PublisherController(
mockPublisherService.Object,
mockLanguageService.Object);
return(publisherController);
}
public PublisherControllerTest()
{
var mapperMock = new Mock <IMapper>();
_publisherServiceMock = new Mock <IPublisherService>();
_publisherServiceMock.Setup(p => p.GetPublisherByCompany(It.IsAny <string>(), true)).Returns(new Publisher());
mapperMock.Setup(m => m.Map <Publisher, PublisherViewModel>(It.IsAny <Publisher>()))
.Returns(new PublisherViewModel());
mapperMock.Setup(m => m.Map <PublisherViewModel>(It.IsAny <Publisher>()))
.Returns(new PublisherViewModel());
_publisherServiceMock.Setup(p => p.GetPublisherByCompany(It.IsAny <string>(), It.IsAny <bool>()))
.Returns(new Publisher());
_publisherController = new PublisherController(mapperMock.Object, _publisherServiceMock.Object);
}
public void Index_Returns_All_Journals()
{
//Arrange
IJournalRepository repository = null;
PublisherController controller = ArrangePublisherController(out repository);
//Act
var actionResult = controller.Index();
//Assert
Assert.IsInstanceOfType(actionResult, typeof(ViewResult));
var model = ((ViewResult)actionResult).Model as IEnumerable <JournalViewModel>;
Assert.AreEqual(JournalMocks.JournalData.Count(c => c.JournalId == null || c.JournalId == 0), model.Count());
}
private static PublisherController ArrangePublisherController(out IJournalRepository repository)
{
Mapper.CreateMap <JournalViewModel, Journal>();
Mapper.CreateMap <Journal, JournalViewModel>();
var profile = JournalMocks.StubUserProfile();
repository = JournalMocks.MockJournalRepository(profile).MockObject;
IStaticMembershipService memServiceMock = JournalMocks.MockIStaticMembershipService(profile).MockObject;
ISessionProvider sessionProvider = JournalMocks.MockISessionProvider(profile).MockObject;
PublisherController controller = new PublisherController(repository, memServiceMock);
controller.CheckRequestAuthenticatd = false;
controller.SetSessionProvider(sessionProvider);
return(controller);
}
public void Journal_Created_Redirect_Success()
{
//Arrange
IJournalRepository repository = null;
PublisherController controller = ArrangePublisherController(out repository);
var file = JournalMocks.MockFile();
//Act
var actionResult = (RedirectToRouteResult)controller.Create(new JournalViewModel {
Id = 1, Description = "TEST", File = file.MockObject, JournalId = null
});
//Assert
Assert.IsInstanceOfType(actionResult, typeof(RedirectToRouteResult));
Assert.AreEqual(((RedirectToRouteResult)actionResult).RouteValues["action"].ToString().Trim().ToUpper(), "INDEX");
}
public void Check_That_Right_Method_Was_Called_Inside_Add_Action()
{
// Arrange
var mockPublisherService = new Mock <IPublisherService>();
mockPublisherService.Setup(x => x.Add(It.IsAny <PublisherModel>())).Verifiable();
PublisherController publisherController = GetPublisherController(mockPublisherService);
PublisherAddUpdateViewModel publisherAddUpdateViewModel = GetPublisherAddUpdateViewModel();
// Act
publisherController.Add(publisherAddUpdateViewModel);
// Assert
mockPublisherService.Verify(m => m.Add(It.IsAny <PublisherModel>()));
}
public void Check_That_Right_Method_Was_Called_Inside_Details_Action()
{
// Arrange
var mockPublisherService = new Mock <IPublisherService>();
mockPublisherService.Setup(x => x.GetModelByCompanyName(It.IsAny <string>()))
.Returns(GetPublisherModel);
PublisherController publisherController = GetPublisherController(mockPublisherService);
const string key = "key";
// Act
publisherController.GetDetails(key);
// Assert
mockPublisherService.Verify(m => m.GetModelByCompanyName(It.IsAny <string>()));
}
public MainWindow()
{
AuthForm();
InitializeComponent();
libraryController = IOCContainer.Injector.Inject(typeof(LibraryController)) as LibraryController;
sectionController = IOCContainer.Injector.Inject(typeof(SectionController)) as SectionController;
authorController = IOCContainer.Injector.Inject(typeof(AuthorController)) as AuthorController;
publisherController = IOCContainer.Injector.Inject(typeof(PublisherController)) as PublisherController;
authorBookController = IOCContainer.Injector.Inject(typeof(AuthorBookController)) as AuthorBookController;
bookController = IOCContainer.Injector.Inject(typeof(BookController)) as BookController;
clientController = IOCContainer.Injector.Inject(typeof(ClientController)) as ClientController;
bookClientController = IOCContainer.Injector.Inject(typeof(BookClientController)) as BookClientController;
bookClientArchiveController = IOCContainer.Injector.Inject(typeof(BookClientArchiveController)) as BookClientArchiveController;
userController = IOCContainer.Injector.Inject(typeof(UserController)) as UserController;
reportController = IOCContainer.Injector.Inject(typeof(ReportController)) as ReportController;
SetRights();
ReadLibraries();
}
public void Create_Returns_Journals()
{
Mapper.CreateMap <Journal, JournalViewModel>();
//Arrange
var membershipRepository = Mock.Create <IStaticMembershipService>();
var userMock = Mock.Create <MembershipUser>();
Mock.Arrange(() => userMock.ProviderUserKey).Returns(1);
Mock.Arrange(() => membershipRepository.GetUser()).Returns(userMock);
var journalRepository = Mock.Create <IJournalRepository>();
Mock.Arrange(() => journalRepository.AddJournal(new Journal()
{
Id = 1,
ContentType = "pdf"
})).IgnoreArguments().Returns(
new OperationStatus()
{
Status = true
}).MustBeCalled();
Mapper.CreateMap <Journal, JournalViewModel>();
Mapper.CreateMap <JournalViewModel, Journal>();
//Act
PublisherController controller = new PublisherController(journalRepository, membershipRepository);
ActionResult actionResult = controller.Create(new JournalViewModel()
{
ContentType = "pdf",
Content = new byte[1],
Id = 1,
Description = "abc"
});
//Assert
Assert.IsNotNull(actionResult);
}
public void TestCreatePublisher()
{
var controller = new PublisherController();
}
public void PrepareForUser(string username)
{
controller = new PublisherController(username);
}
public void PublisherController_should_throw_ArgumentNullException_if_input_service_is_null()
{
// Act & Assert
Assert.Throws <ArgumentNullException>(() => _publisherController = new PublisherController(null));
}
public void Initialize()
{
_publisherService = new Mock <IPublisherService>();
_publisherController = new PublisherController(_publisherService.Object);
}
public frmAddPublisher()
{
InitializeComponent();
_publisherController = new PublisherController();
}
