public void SetUp()
        {
            urls = MockRepository.GenerateMock<IUrlRegistry>();
            page = MockRepository.GenerateMock<IFubuPage>();

            page.Stub(x => x.Urls).Return(urls);
        }
 public void SetUp()
 {
     _page = MockRepository.GenerateStub<IFubuPage<ViewModel>>();
     _convention = MockRepository.GenerateStub<IElementNamingConvention>();
     _expression = (x=>x.Property);
     _accessor = _expression.ToAccessor();
     _convention.Stub(c => c.GetName(Arg<Type>.Is.Equal(typeof (ViewModel)), Arg<Accessor>.Is.Equal(_accessor))).Return("name");
     _page.Stub(p => p.Get<IElementNamingConvention>()).Return(_convention);
 }
        public void SetUp()
        {
            _page = MockRepository.GenerateMock<IFubuPage>();
            _urls = new StubUrlRegistry();

            _page.Expect(p => p.Urls).Return(_urls);
            _model = new InputModel();
            //_urls.Stub(u => u.UrlFor(Arg<InputModel>.Is.NotNull)).Return("some url");
        }
        public void SetUp()
        {
            thePage = MockRepository.GenerateMock<IFubuPage>();
            theRequirements = MockRepository.GenerateMock<IAssetRequirements>();

            thePage.Stub(x => x.Get<IAssetRequirements>()).Return(theRequirements);

            theWriter = MockRepository.GenerateMock<IAssetTagWriter>();
            thePage.Stub(x => x.Get<IAssetTagWriter>()).Return(theWriter);

            theTagList = new TagList(new HtmlTag[0]);
        }
        public void SetUp()
        {
            var registry = new FubuRegistry(x => x.HtmlConvention<TestHtmlConventions>());
            var container = new Container(x => x.For<IFubuRequest>().Singleton());
            var facility = new StructureMapContainerFacility(container);
            new FubuBootstrapper(facility, registry).Bootstrap(new List<RouteBase>());
            var generator = container.GetInstance<TagGenerator<ViewModel>>();

            _page = MockRepository.GenerateMock<IFubuPage<ViewModel>>();
            _page.Expect(p => p.Model).Return(new ViewModel());
            _page.Expect(p => p.Get<TagGenerator<ViewModel>>()).Return(generator);
        }
        public void SetUp()
        {
            _page = MockRepository.GenerateStub<IFubuPage>();
            _partialFactory = MockRepository.GenerateStub<IPartialFactory>();
            _behavior = new WrappingBehavior();
            PartialInvokingHandler = MockRepository.GenerateStub<IPartialInvokingHandler>();
            _behavior.InsideBehavior = new PartialHandlingBehavior();

            _partialFactory.Stub(f => f.BuildPartial(typeof(InputModel))).Return(_behavior);
            _page.Stub(p => p.Get<IPartialFactory>()).Return(_partialFactory);

            _request = MockRepository.GenerateStub<IFubuRequest>();
            _page.Stub(p => p.Get<IFubuRequest>()).Return(_request);
        }
        public void SetUp()
        {
            _page = MockRepository.GenerateMock<IFubuPage<InputModel>>();
            _renderer = MockRepository.GenerateStub<IPartialRenderer>();
            _serviceLocator = MockRepository.GenerateStub<IServiceLocator>();
            
            _viewTypeRegistry = MockRepository.GenerateStub<IPartialViewTypeRegistry>();
            _serviceLocator.Stub(s => s.GetInstance<IPartialViewTypeRegistry>()).Return(_viewTypeRegistry);

            
            _model = new InputModel{Partials=new List<PartialModel>{new PartialModel()}};
            _page.Expect(p => p.Get<IElementGenerator<InputModel>>()).Return(MockRepository.GenerateMock<IElementGenerator<InputModel>>());;
            _page.Expect(p => p.Model).Return(_model);
            _page.Expect(p => p.Get<IPartialRenderer>()).Return(_renderer);
            _page.Expect(p => p.ServiceLocator).Return(_serviceLocator);
        }
        public void SetUp()
        {
            _mocks = new MockRepository();
            _view = MockRepository.GenerateStub<IFubuPage>();
            _partialView = MockRepository.GenerateStub<IFubuPage>();
            _renderer = MockRepository.GenerateMock<IPartialRenderer>();
            _tagGenerator = MockRepository.GenerateMock<IElementGenerator<TestModel>>();
            _endpointService = MockRepository.GenerateMock<IEndpointService>();
            _model = new TestModel();
            _partialModel = new PartialTestModel();

            _model.PartialModel = _partialModel;

            _expression = new RenderPartialExpression<TestModel>(_model, _view, _renderer,_tagGenerator, _endpointService);
            _expression.Using<IFubuPage>(v => { _wasCalled = true; });
        }
        public void SetUp()
        {
            _resultingTag = null;

            page = MockRepository.GenerateMock<IFubuPage>();
            endpoints = MockRepository.GenerateMock<IEndpointService>();

            page.Expect(x => x.Get<IEndpointService>()).Return(endpoints);

            theFinder = s => s.EndpointForNew<SomeEntity>();

            theEndpoint = new Endpoint(){
                IsAuthorized = false,
                Url = "some url"
            };

            endpoints.Expect(x => x.EndpointForNew<SomeEntity>()).Return(theEndpoint);
        }
        public void SetUp()
        {
            _page = MockRepository.GenerateMock<IFubuPage<InputModel>>();
            _renderer = MockRepository.GenerateStub<IPartialRenderer>();
            var serviceLocator = MockRepository.GenerateStub<IServiceLocator>();
            var namingConvention = MockRepository.GenerateStub<IElementNamingConvention>();
            _tags = new TagGenerator<InputModel>(new TagProfileLibrary(), namingConvention,
                                                 serviceLocator);

            _viewTypeRegistry = MockRepository.GenerateStub<IPartialViewTypeRegistry>();
            serviceLocator.Stub(s => s.GetInstance<IPartialViewTypeRegistry>()).Return(_viewTypeRegistry);

            var inMemoryFubuRequest = new InMemoryFubuRequest();
            inMemoryFubuRequest.Set(new InputModel());

            _page.Stub(s => s.Get<IFubuRequest>()).Return(inMemoryFubuRequest);

            _model = new InputModel{Partials=new List<PartialModel>{new PartialModel()}};
            _page.Expect(p => p.Get<ITagGenerator<InputModel>>()).Return(_tags);
            _page.Expect(p => p.Model).Return(_model);
            _page.Expect(p => p.Get<IPartialRenderer>()).Return(_renderer);
            _page.Expect(p => p.ServiceLocator).Return(serviceLocator);
        }
Exemple #11
0
        /// <summary>
        /// Writes an <image> tag for the named assetName using the url from the asset pipeline
        /// </summary>
        /// <param name="page"></param>
        /// <param name="assetName"></param>
        /// <returns></returns>
        public static HtmlTag ImageFor(this IFubuPage page, string assetName)
        {
            var url = page.Urls.UrlForAsset(AssetFolder.images, assetName);

            return(new HtmlTag("img").Attr("src", url));
        }
 public static string Partial <TInputModel>(this IFubuPage page) where TInputModel : class
 {
     return(InvokePartial <TInputModel>(page, null));
 }
Exemple #13
0
 /// <summary>
 ///   Builds a tag that accepts user input for a property of the page's view model
 /// </summary>
 /// <typeparam name = "T">The model type of the strongly typed view</typeparam>
 /// <param name = "page">The view</param>
 /// <param name = "expression">An expression that specifies a property on the model</param>
 /// <returns></returns>
 public static HtmlTag InputFor <T>(this IFubuPage <T> page, Expression <Func <T, object> > expression)
     where T : class
 {
     return(page.Tags().InputFor(expression));
 }
Exemple #14
0
 /// <summary>
 ///   Builds a tag that displays the current value of a property on a given model
 /// </summary>
 /// <typeparam name = "T">The type of the given model</typeparam>
 /// <param name = "page">The view</param>
 /// <param name = "model">The model used to provide values for the tag</param>
 /// <param name = "expression">An expression that specifies a property on the provided model</param>
 /// <returns></returns>
 public static HtmlTag DisplayFor <T>(this IFubuPage page, T model, Expression <Func <T, object> > expression)
     where T : class
 {
     return(page.Tags(model).DisplayFor(expression));
 }
 public static HtmlTag FormFor(this IFubuPage page, string url)
 {
     url = page.Get <IHttpRequest>().ToFullUrl(url);
     return(new FormTag(url).NoClosingTag());
 }
Exemple #16
0
        public static string LinkVariable(this IFubuPage page, string variable, object input)
        {
            var url = page.Urls.UrlFor(input);

            return("var {0} = '{1}';".ToFormat(variable, url));
        }
 public static IHtmlString PartialFor(this IFubuPage page, object input, bool withModelBinding = false, string categoryOrHttpMethod = null)
 {
     return(new HtmlString(page.Get <IPartialInvoker>().InvokeAsHtml(input).GetAwaiter().GetResult()));
 }
 public void SetUp()
 {
     _page = MockRepository.GenerateMock<IFubuPage>();
     _urls = new StubUrlRegistry();
     _model = new InputModel();
     _page.Stub(p => p.Urls).Return(_urls);
 }
        public static HtmlTag FormFor(this IFubuPage view, ChainSearch search, object input)
        {
            var request = new FormRequest(search, input);

            return(view.Get <ITagGeneratorFactory>().GeneratorFor <FormRequest>().Build(request));
        }
 public static IHtmlString EndForm(this IFubuPage page)
 {
     return(new HtmlString("</form>"));
 }
        public static HtmlTag FormFor <TController>(this IFubuPage view, Expression <Action <TController> > expression)
        {
            var search = ChainSearch.ForMethod(expression, "POST");

            return(view.FormFor(search, null));
        }
 public static HtmlTag FormFor <TInputModel>(this IFubuPage page, TInputModel model)
 {
     return(page.FormFor(ChainSearch.ByUniqueInputType(model.GetType(), "POST"), model));
 }
        public static HtmlTag FormFor <TInputModel>(this IFubuPage page, Action <HtmlTag> configure) where TInputModel : new()
        {
            var search = ChainSearch.ByUniqueInputType(typeof(TInputModel), "POST");

            return(page.FormFor(search, new TInputModel(), configure));
        }
        public void SetUp()
        {
            _page = MockRepository.GenerateStub<IFubuPage>();
            _partialFactory = MockRepository.GenerateStub<IPartialFactory>();
            _behavior = MockRepository.GenerateStub<IActionBehavior>();

            _partialFactory.Stub(f => f.BuildPartial(typeof (InputModel))).Return(_behavior);
            _page.Stub(p => p.Get<IPartialFactory>()).Return(_partialFactory);

            _request = MockRepository.GenerateStub<IFubuRequest>();
            _page.Stub(p => p.Get<IFubuRequest>()).Return(_request);
        }
 public static string InvokePartial <TInputModel>(IFubuPage page, string prefix, string categoryOrHttpMethod = null) where TInputModel : class
 {
     return(page.Get <IPartialInvoker>().Invoke <TInputModel>(categoryOrHttpMethod).GetAwaiter().GetResult());
 }
 public void Activate(IServiceLocator services, IFubuPage page)
 {
     _action(services, page);
 }
 public static IHtmlString Partial <TInputModel>(this IFubuPage page, string categoryOrHttpMethod = null) where TInputModel : class
 {
     return(new HtmlString(InvokePartial <TInputModel>(page, null, categoryOrHttpMethod)));
 }
Exemple #28
0
        public void Activate(IFubuPage page)
        {
            page.ServiceLocator = _services;

            _ruleCache.ActivationsFor(page.GetType()).Each(rule => rule.Activate(_services, page));
        }
 public static HtmlTag SectionFor(this IFubuPage page, string text, string id)
 {
     return(new HtmlTag("section", tag => tag.Add("h4").Text(text).AddClass("section-header")).Id(id).NoClosingTag());
 }
Exemple #30
0
 public static HtmlTag LinkToNew <T>(this IFubuPage page)
 {
     return(page.AuthorizedLinkTo(x => x.EndpointForNew <T>()));
 }
Exemple #31
0
 public static string Notification <T>(this IFubuPage page, T notification)
     where T : class, INotificationModel
 {
     return(page.Get <PartialInvoker>().InvokeObject(notification));
 }
Exemple #32
0
 public static string LinkVariable <TInput>(this IFubuPage page, string variable) where TInput : new()
 {
     return(page.LinkVariable(variable, new TInput()));
 }
Exemple #33
0
        public string Render <T>(IFubuPage parentPage, IFubuPage partialControl, T viewModel, string prefix) where T : class
        {
            setParentPageIfNotAlreadySet(partialControl, (Control)parentPage);

            return(Render(partialControl, viewModel, prefix));
        }
Exemple #34
0
 /// <summary>
 ///   Builds a tag that displays the name of a property on a model retrieved from the <see cref = "IFubuRequest" />
 /// </summary>
 /// <typeparam name = "T">The type to retrieve from the request</typeparam>
 /// <param name = "page">The view</param>
 /// <param name = "expression">An expression that specifies a property on the retrieved type instance</param>
 /// <returns></returns>
 public static HtmlTag LabelFor <T>(this IFubuPage page, Expression <Func <T, object> > expression) where T : class
 {
     return(page.Tags <T>().LabelFor(expression));
 }
Exemple #35
0
        private static IHtmlString apply <T>(IEnumerable <IContentExtension <T> > extensions, IFubuPage <T> page, string tag)
            where T : class
        {
            var extensionOutput = extensions.SelectMany(ex => ex.GetExtensions(page)).Where(o => o != null).ToArray();

            if (extensionOutput.Length == 0 && FubuMode.InDevelopment())
            {
                page.Write("<!-- Content extensions '{1}' for {0} would be rendered here -->".ToFormat(typeof(T).Name,
                                                                                                       tag));
            }

            var output = new StringBuilder();

            extensionOutput.Each(o => output.Append(o).AppendLine());

            return(new HtmlString(output.ToString()));
        }
Exemple #36
0
 public static string ElementNameFor <T>(this IFubuPage <T> page, Expression <Func <T, object> > expression)
     where T : class
 {
     return(page.Get <IElementNamingConvention>().GetName(typeof(T), expression.ToAccessor()));
 }
 public void SetUp()
 {
     page = MockRepository.GenerateMock<IFubuPage>();
 }
        public void SetUp()
        {
            _mocks = new MockRepository();
            _view = MockRepository.GenerateStub<IFubuPage>();
            _partialView = MockRepository.GenerateStub<IFubuPage>();
            _request = new InMemoryFubuRequest();
            _renderer = MockRepository.GenerateMock<IPartialRenderer>();

            _model = new TestModel();
            _partialModel = new PartialTestModel();

            _model.PartialModel = _partialModel;

            _request.Set(_model);

            _expression = new RenderPartialExpression<TestModel>(_view, _renderer, _request);
            _expression.Using<IFubuPage>(v => { _wasCalled = true; });
        }
Exemple #39
0
 public IHtmlString ApplyExtensions <T>(IFubuPage <T> page, string tag) where T : class
 {
     return(apply(ShelfFor <T>().ExtensionsFor(tag), page, tag));
 }
Exemple #40
0
        public void SetUp()
        {
            tags = new StubTagGenerator<ViewModel>();
            _expression = null;

            page = MockRepository.GenerateMock<IFubuPage<ViewModel>>();
            page.Stub(x => x.Get<ITagGenerator<ViewModel>>()).Return(tags);
            page.Stub(x => x.Model).Return(new ViewModel());

            fieldAccess = MockRepository.GenerateMock<IFieldAccessService>();
            page.Stub(x => x.Get<IFieldAccessService>()).Return(fieldAccess);
        }
 public static HtmlTag FiltersFor(this IFubuPage page, GridViewModel model)
 {
     page.Script("grid");
     return(page.Get <FilterTagWriter>().FilterTemplatesFor(model));
 }
 public static string InvokePartial <TInputModel>(IFubuPage page, string prefix) where TInputModel : class
 {
     return(page.Get <IPartialInvoker>().Invoke <TInputModel>());
 }
 public static HtmlTag SmartGridFor <T>(this IFubuPage page, int?initialRows) where T : ISmartGrid
 {
     return(page.SmartGridFor <T>(initialRows, h => { }));
 }
 private static object GetBodyContent(IFubuPage<NewTodoOutput> page)
 {
     return page.RenderPartialFor(new Reminder()).Using<NewReminder>().ToString();
 }
 public static HtmlTag SmartGridFor <TGrid>(this IFubuPage page, int?initialRows, params object[] arguments)
     where TGrid : ISmartGrid
 {
     return(page.SmartGridFor <TGrid>(initialRows, h => h.RegisterArguments(arguments)));
 }
        public void SetUp()
        {
            var registry = new FubuRegistry(x => x.HtmlConvention<TestHtmlConventions>());
            var container = new Container(x => x.For<IFubuRequest>().Singleton());
            var facility = new StructureMapContainerFacility(container);
            new FubuBootstrapper(facility, registry).Bootstrap(new List<RouteBase>());

            var generator = container.GetInstance<TagGenerator<ArbitraryModel>>();
            _page = MockRepository.GenerateMock<IFubuPage>();
            _page.Stub(p => p.Get<TagGenerator<ArbitraryModel>>()).Return(generator);
            _givenModel = new ArbitraryModel { City = "Austin" };
        }
Exemple #47
0
 public void Activate(IFubuPage page)
 {
 }
Exemple #48
0
 public IHtmlString ApplyExtensions <T>(IFubuPage <T> page) where T : class
 {
     return(apply(ShelfFor <T>().AllExtensions(), page, "ALL"));
 }
 public static HtmlTag FormFor(this IFubuPage page)
 {
     return(new FormTag().NoClosingTag());
 }