Пример #1
0
        public async Task TestAddByBookmarklet_Get()
        {
            // arrange
            var title         = "タイトル1";
            var url           = "http://www.mochaware.jp/";
            var pagedRefLists = ObjectMother.GetPagedRefLists();
            var queryStrs     = new NameValueCollection()
            {
                { "title", title },
            };

            MapConfig.CreateMaps();
            MochaContainer.RegisterTypes = ObjectMother.RegisterAuthenticatedUserContext;
            MochaContainer.GetContainer();

            var mocks = new ControllerContextMocks();

            mocks.UnvalidatedRequestValues.Setup(u => u.QueryString).Returns(queryStrs);
            mocks.Request.Setup(r => r.IsAuthenticated).Returns(true);

            var handlerMock = new Mock <IRefListHandler>();

            handlerMock.Setup(h => h.GetRefListsAsync(It.IsAny <GetRefListsRequest>())).ReturnsAsync(pagedRefLists);

            var controller = new ListController(null, null, handlerMock.Object, null, null);

            controller.ControllerContext = mocks.CreateControllerContext(controller);

            // act
            var result = await controller.AddByBookmarklet(url) as ViewResult;

            // assert
            var model = result.Model as AddByBookmarkletPageViewModel;

            Assert.IsNotNull(result);
            Assert.AreEqual("", result.ViewName);
            Assert.AreEqual(
                pagedRefLists.RefLists.FirstOrDefault().Title,
                model.RefLists.FirstOrDefault().Title
                );
        }
        public void Initialize()
        {
            Bootstrapper.SetupAutoMapper();

            _serviceDesk = UnitTestHelper.GenerateRandomData <ServiceDesk>();

            _domainTypeRefDatas = new List <DomainTypeRefData>
            {
                UnitTestHelper.GenerateRandomData <DomainTypeRefData>(x =>
                {
                    x.Id      = 1;
                    x.Visible = true;
                }),
                UnitTestHelper.GenerateRandomData <DomainTypeRefData>(x =>
                {
                    x.Id      = 2;
                    x.Visible = false;
                }),
                UnitTestHelper.GenerateRandomData <DomainTypeRefData>(x =>
                {
                    x.Id      = 3;
                    x.Visible = false;
                }),
                UnitTestHelper.GenerateRandomData <DomainTypeRefData>(x =>
                {
                    x.Id      = 4;
                    x.Visible = true;
                }),
                UnitTestHelper.GenerateRandomData <DomainTypeRefData>(x =>
                {
                    x.Id      = 5;
                    x.Visible = true;
                })
            };

            _mockDomainTypeRefDataService = new Mock <IDomainTypeRefDataService>();
            _mockDomainTypeRefDataService.Setup(s => s.GetById(1)).Returns(_domainTypeRefDatas[0]);
            _mockDomainTypeRefDataService.Setup(s => s.GetById(2)).Returns(_domainTypeRefDatas[1]);
            _mockDomainTypeRefDataService.Setup(s => s.GetById(3)).Returns(_domainTypeRefDatas[2]);
            _mockDomainTypeRefDataService.Setup(s => s.GetById(4)).Returns(_domainTypeRefDatas[3]);
            _mockDomainTypeRefDataService.Setup(s => s.GetById(5)).Returns(_domainTypeRefDatas[4]);
            _mockDomainTypeRefDataService.Setup(s => s.GetAllAndNotVisibleForCustomer(CustomerId))
            .Returns(_domainTypeRefDatas);

            _serviceDomain = UnitTestHelper.GenerateRandomData <ServiceDomain>();
            _serviceDomain.ServiceFunctions = new List <ServiceFunction>();

            _serviceDomainListItems = new List <ServiceDomainListItem>
            {
                UnitTestHelper.GenerateRandomData <ServiceDomainListItem>(),
                UnitTestHelper.GenerateRandomData <ServiceDomainListItem>(),
                UnitTestHelper.GenerateRandomData <ServiceDomainListItem>(),
                UnitTestHelper.GenerateRandomData <ServiceDomainListItem>(),
                UnitTestHelper.GenerateRandomData <ServiceDomainListItem>(),
            };

            _templateListItems = new List <TemplateListItem>
            {
                UnitTestHelper.GenerateRandomData <TemplateListItem>(x =>
                {
                    x.Id           = TemplateId;
                    x.TemplateType = TemplateTypeNames.SORT;
                }),
                UnitTestHelper.GenerateRandomData <TemplateListItem>(),
                UnitTestHelper.GenerateRandomData <TemplateListItem>(),
                UnitTestHelper.GenerateRandomData <TemplateListItem>()
            };

            _mockServiceDomainService = new Mock <IServiceDomainService>();
            _mockServiceDomainService.Setup(s => s.GetByCustomerAndId(CustomerId, ServiceDomainId))
            .Returns(_serviceDomain);
            _mockServiceDomainService.Setup(s => s.GetById(ServiceDomainId)).Returns(_serviceDomain);
            _mockServiceDomainService.Setup(s => s.ServiceDeskDomains(ServiceDeskId))
            .Returns(_serviceDomainListItems.AsQueryable());
            _mockServiceDomainService.Setup(s => s.CustomerServiceDomains(CustomerId))
            .Returns(_serviceDomainListItems.AsQueryable());

            _mockResponseManager = new Mock <IResponseManager>();
            _mockRequestManager  = new Mock <IRequestManager>();

            _mockUserManager = new Mock <IUserManager>();
            _mockUserManager.Setup(s => s.Name).Returns(UserName);

            _mockNameValueCollection = new Mock <NameValueCollection>();

            _mockContextManager = new Mock <IContextManager>();
            _mockContextManager.Setup(s => s.UserManager).Returns(_mockUserManager.Object);
            _mockContextManager.Setup(s => s.ResponseManager).Returns(_mockResponseManager.Object);
            _mockContextManager.Setup(s => s.RequestManager).Returns(_mockRequestManager.Object);
            _mockRequestManager.Setup(s => s.Form).Returns(_mockNameValueCollection.Object);

            _serviceDesks = new List <ServiceDesk>
            {
                UnitTestHelper.GenerateRandomData <ServiceDesk>(),
                UnitTestHelper.GenerateRandomData <ServiceDesk>(),
                UnitTestHelper.GenerateRandomData <ServiceDesk>(x =>
                {
                    x.Id = ServiceDeskId;
                }),
                UnitTestHelper.GenerateRandomData <ServiceDesk>(),
                UnitTestHelper.GenerateRandomData <ServiceDesk>()
            };

            _mockServiceDeskService = new Mock <IServiceDeskService>();
            _mockServiceDeskService.Setup(s => s.GetByCustomer(CustomerId)).Returns(_serviceDesks.AsQueryable());
            _mockServiceDeskService.Setup(s => s.GetByCustomerAndId(CustomerId, ServiceDeskId)).Returns(_serviceDesk);

            _mockAppUserContext = new Mock <IAppUserContext>();
            _mockAppUserContext.Setup(s => s.Current).Returns(new AppContext
            {
                CurrentCustomer = new CurrentCustomerViewModel
                {
                    Id = CustomerId
                }
            });

            _mockTemplateService = new Mock <ITemplateService>();
            _mockTemplateService.Setup(s => s.GetById(TemplateId))
            .Returns(new Template {
                Id = TemplateId, Filename = "example.xlxs"
            });
            _mockTemplateService.Setup(s => s.AllTemplates())
            .Returns(_templateListItems);

            _mockServiceDecompositionTemplateDataImportProcessor = new Mock <IServiceDecompositionTemplateDataImportProcessor>();
            _mockServiceDecompositionDesignDataImportProcessor   = new Mock <IServiceDecompositionDesignDataImportProcessor>();
            _mockTemplateProcessor = new Mock <ITemplateProcessor>();


            _target = new TemplateController(_mockTemplateService.Object,
                                             _mockServiceDeskService.Object,
                                             _mockServiceDecompositionTemplateDataImportProcessor.Object,
                                             _mockServiceDecompositionDesignDataImportProcessor.Object,
                                             _mockTemplateProcessor.Object,
                                             _mockContextManager.Object,
                                             _mockAppUserContext.Object);

            _controllerContextMocks   = new ControllerContextMocks();
            _target.ControllerContext = new ControllerContext(_controllerContextMocks.MockHttpContextBase.Object,
                                                              new RouteData(),
                                                              _target);
            if (RouteTable.Routes.Count == 0)
            {
                RouteConfig.RegisterRoutes(RouteTable.Routes);
            }
            _target.Url =
                new UrlHelper(new RequestContext(_controllerContextMocks.MockHttpContextBase.Object, new RouteData()));
        }