public void ExceptionThrownIsHandled()
{
var environment = new Mock <IReactEnvironment>();
environment.Setup(x => x.Execute <bool>("typeof Foo !== 'undefined'")).Returns(true);
environment.Setup(x => x.Execute <string>(@"ReactDOMServer.renderToString(React.createElement(Foo, {""hello"":""World""}))"))
.Throws(new JsRuntimeException("'undefined' is not an object"));
var config = new Mock <IReactSiteConfiguration>();
config.Setup(x => x.UseServerSideRendering).Returns(true);
config.Setup(x => x.ExceptionHandler).Returns(() => throw new ReactServerRenderingException("test"));
var reactIdGenerator = new Mock <IReactIdGenerator>();
var component = new ReactComponent(environment.Object, config.Object, reactIdGenerator.Object, "Foo", "container")
{
Props = new { hello = "World" }
};
// Default behavior
bool exceptionCaught = false;
try
{
component.RenderHtml();
}
catch (ReactServerRenderingException)
{
exceptionCaught = true;
}
Assert.True(exceptionCaught);
// Custom handler passed into render call
bool customHandlerInvoked = false;
Action <Exception, string, string> customHandler = (ex, name, id) => customHandlerInvoked = true;
component.RenderHtml(exceptionHandler: customHandler);
Assert.True(customHandlerInvoked);
// Custom exception handler set
Exception caughtException = null;
config.Setup(x => x.ExceptionHandler).Returns((ex, name, id) => caughtException = ex);
var result = component.RenderHtml();
Assert.Equal(@"<div id=""container""></div>", result);
Assert.NotNull(caughtException);
}
public void RenderFunctionsCalled()
{
var environment = new Mock <IReactEnvironment>();
environment.Setup(x => x.Execute <bool>("typeof Foo !== 'undefined'")).Returns(true);
environment.Setup(x => x.Execute <string>(@"outerWrap(ReactDOMServer.renderToString(wrap(React.createElement(Foo, {""hello"":""World""}))))"))
.Returns("[HTML]");
environment.Setup(x => x.Execute <string>(@"prerender();"))
.Returns("prerender-result");
environment.Setup(x => x.Execute <string>(@"postrender();"))
.Returns("postrender-result");
var config = new Mock <IReactSiteConfiguration>();
config.Setup(x => x.UseServerSideRendering).Returns(true);
var reactIdGenerator = new Mock <IReactIdGenerator>();
var component = new ReactComponent(environment.Object, config.Object, reactIdGenerator.Object, "Foo", "container")
{
Props = new { hello = "World" }
};
var renderFunctions = new TestRenderFunctions();
var result = component.RenderHtml(renderFunctions: renderFunctions);
Assert.Equal(@"<div id=""container"">[HTML]</div>", result);
Assert.Equal(@"prerender-result", renderFunctions.PreRenderResult);
Assert.Equal(@"postrender-result", renderFunctions.PostRenderResult);
}
public void RenderHtmlShouldThrowExceptionIfComponentDoesNotExist()
{
var environment = new Mock<IReactEnvironment>();
environment.Setup(x => x.Execute<bool>("typeof Foo !== 'undefined'")).Returns(false);
var component = new ReactComponent(environment.Object, null, "Foo", "container");
Assert.Throws<ReactInvalidComponentException>(() =>
{
component.RenderHtml();
});
}
public void RenderHtmlShouldThrowExceptionIfComponentDoesNotExist()
{
var environment = new Mock<IReactEnvironment>();
environment.Setup(x => x.HasVariable("Foo")).Returns(false);
var component = new ReactComponent(environment.Object, "Foo", "container");
Assert.Throws<ReactInvalidComponentException>(() =>
{
component.RenderHtml();
});
}
public void RenderHtmlShouldThrowExceptionIfComponentDoesNotExist()
{
var environment = new Mock <IReactEnvironment>();
environment.Setup(x => x.HasVariable("Foo")).Returns(false);
var component = new ReactComponent(environment.Object, "Foo", "container");
Assert.Throws <ReactInvalidComponentException>(() =>
{
component.RenderHtml();
});
}
public void RenderHtmlShouldThrowExceptionIfComponentDoesNotExist()
{
var environment = new Mock <IReactEnvironment>();
environment.Setup(x => x.Execute <bool>("typeof Foo !== 'undefined'")).Returns(false);
var component = new ReactComponent(environment.Object, "Foo", "container");
Assert.Throws <ReactInvalidComponentException>(() =>
{
component.RenderHtml();
});
}
public void RenderHtmlShouldCallRenderComponent()
{
var environment = new Mock<IReactEnvironment>();
environment.Setup(x => x.HasVariable("Foo")).Returns(true);
var component = new ReactComponent(environment.Object, "Foo", "container")
{
Props = new { hello = "World" }
};
component.RenderHtml();
environment.Verify(x => x.Execute<string>(@"React.renderComponentToString(Foo({""hello"":""World""}))"));
}
public void RenderHtmlShouldCallRenderComponent()
{
var environment = new Mock<IReactEnvironment>();
environment.Setup(x => x.Execute<bool>("typeof Foo !== 'undefined'")).Returns(true);
var config = new Mock<IReactSiteConfiguration>();
var component = new ReactComponent(environment.Object, config.Object, "Foo", "container")
{
Props = new { hello = "World" }
};
component.RenderHtml();
environment.Verify(x => x.Execute<string>(@"React.renderToString(React.createElement(Foo, {""hello"":""World""}))"));
}
public void RenderHtmlShouldCallRenderComponent()
{
var environment = new Mock <IReactEnvironment>();
environment.Setup(x => x.Execute <bool>("typeof Foo !== 'undefined'")).Returns(true);
var component = new ReactComponent(environment.Object, "Foo", "container")
{
Props = new { hello = "World" }
};
component.RenderHtml();
environment.Verify(x => x.Execute <string>(@"React.renderComponentToString(Foo({""hello"":""World""}))"));
}
public void RenderHtmlShouldWrapComponentInDiv()
{
var environment = new Mock<IReactEnvironment>();
environment.Setup(x => x.HasVariable("Foo")).Returns(true);
environment.Setup(x => x.Execute<string>(@"React.renderComponentToString(Foo({""hello"":""World""}))"))
.Returns("[HTML]");
var component = new ReactComponent(environment.Object, "Foo", "container")
{
Props = new { hello = "World" }
};
var result = component.RenderHtml();
Assert.Equal(@"<div id=""container"">[HTML]</div>", result);
}
public void RenderHtmlShouldNotRenderClientSideAttributes()
{
var environment = new Mock <IReactEnvironment>();
environment.Setup(x => x.Execute <bool>("typeof Foo !== 'undefined'")).Returns(true);
var config = new Mock <IReactSiteConfiguration>();
var component = new ReactComponent(environment.Object, config.Object, "Foo", "container")
{
Props = new { hello = "World" }
};
component.RenderHtml(renderServerOnly: true);
environment.Verify(x => x.Execute <string>(@"ReactDOMServer.renderToStaticMarkup(React.createElement(Foo, {""hello"":""World""}))"));
}
public void RenderHtmlShouldWrapComponentInDiv()
{
var environment = new Mock<IReactEnvironment>();
environment.Setup(x => x.Execute<bool>("typeof Foo !== 'undefined'")).Returns(true);
environment.Setup(x => x.Execute<string>(@"React.renderToString(React.createElement(Foo, {""hello"":""World""}))"))
.Returns("[HTML]");
var config = new Mock<IReactSiteConfiguration>();
var component = new ReactComponent(environment.Object, config.Object, "Foo", "container")
{
Props = new { hello = "World" }
};
var result = component.RenderHtml();
Assert.AreEqual(@"<div id=""container"">[HTML]</div>", result);
}
public void RenderHtmlShouldWrapComponentInDiv()
{
var environment = new Mock <IReactEnvironment>();
environment.Setup(x => x.Execute <bool>("typeof Foo !== 'undefined'")).Returns(true);
environment.Setup(x => x.Execute <string>(@"React.renderComponentToString(Foo({""hello"":""World""}))"))
.Returns("[HTML]");
var component = new ReactComponent(environment.Object, "Foo", "container")
{
Props = new { hello = "World" }
};
var result = component.RenderHtml();
Assert.AreEqual(@"<div id=""container"">[HTML]</div>", result);
}
public void RenderHtmlShouldThrowExceptionIfComponentDoesNotExist()
{
var environment = new Mock <IReactEnvironment>();
environment.Setup(x => x.Execute <bool>("typeof Foo !== 'undefined'")).Returns(false);
var config = new Mock <IReactSiteConfiguration>();
config.Setup(x => x.UseServerSideRendering).Returns(true);
var reactIdGenerator = new Mock <IReactIdGenerator>();
var component = new ReactComponent(environment.Object, config.Object, reactIdGenerator.Object, "Foo", "container");
Assert.Throws <ReactInvalidComponentException>(() =>
{
component.RenderHtml();
});
}
public void RenderHtmlShouldWrapComponentInCustomElement()
{
var config = new Mock <IReactSiteConfiguration>();
var environment = new Mock <IReactEnvironment>();
environment.Setup(x => x.Execute <bool>("typeof Foo !== 'undefined'")).Returns(true);
environment.Setup(x => x.Execute <string>(@"React.renderToString(React.createElement(Foo, {""hello"":""World""}))"))
.Returns("[HTML]");
var component = new ReactComponent(environment.Object, config.Object, "Foo", "container")
{
Props = new { hello = "World" },
ContainerTag = "span"
};
var result = component.RenderHtml();
Assert.AreEqual(@"<span id=""container"">[HTML]</span>", result);
}
public void RenderHtmlShouldAddClassToElement()
{
var config = new Mock <IReactSiteConfiguration>();
var environment = new Mock <IReactEnvironment>();
environment.Setup(x => x.Execute <bool>("typeof Foo !== 'undefined'")).Returns(true);
environment.Setup(x => x.Execute <string>(@"ReactDOMServer.renderToString(React.createElement(Foo, {""hello"":""World""}))"))
.Returns("[HTML]");
var component = new ReactComponent(environment.Object, config.Object, "Foo", "container")
{
Props = new { hello = "World" },
ContainerClass = "test-class"
};
var result = component.RenderHtml();
Assert.AreEqual(@"<div id=""container"" class=""test-class"">[HTML]</div>", result);
}
public void RenderHtmlShouldNotRenderComponentHtml()
{
var environment = new Mock <IReactEnvironment>();
environment.Setup(x => x.Execute <bool>("typeof Foo !== 'undefined'")).Returns(true);
environment.Setup(x => x.Execute <string>(@"React.renderToString(React.createElement(Foo, {""hello"":""World""}))"))
.Returns("[HTML]");
var config = new Mock <IReactSiteConfiguration>();
var component = new ReactComponent(environment.Object, config.Object, "Foo", "container")
{
Props = new { hello = "World" }
};
var result = component.RenderHtml(renderContainerOnly: true);
Assert.Equal(@"<div id=""container""></div>", result);
environment.Verify(x => x.Execute(It.IsAny <string>()), Times.Never);
}
public void RenderHtmlShouldCallRenderComponent()
{
var environment = new Mock <IReactEnvironment>();
environment.Setup(x => x.Execute <bool>("typeof Foo !== 'undefined'")).Returns(true);
var config = new Mock <IReactSiteConfiguration>();
config.Setup(x => x.UseServerSideRendering).Returns(true);
var reactIdGenerator = new Mock <IReactIdGenerator>();
var component = new ReactComponent(environment.Object, config.Object, reactIdGenerator.Object, "Foo", "container")
{
Props = new { hello = "World" }
};
component.RenderHtml();
environment.Verify(x => x.Execute <string>(@"ReactDOMServer.renderToString(React.createElement(Foo, {""hello"":""World""}))"));
}
public void RenderHtmlShouldWrapComponentInDiv()
{
var environment = new Mock <IReactEnvironment>();
environment.Setup(x => x.Execute <bool>("typeof Foo !== 'undefined'")).Returns(true);
environment.Setup(x => x.Execute <string>(@"ReactDOMServer.renderToString(React.createElement(Foo, {""hello"":""World""}))"))
.Returns("[HTML]");
var config = CreateDefaultConfigMock();
config.Setup(x => x.UseServerSideRendering).Returns(true);
var reactIdGenerator = new Mock <IReactIdGenerator>();
var component = new ReactComponent(environment.Object, config.Object, reactIdGenerator.Object, "Foo", "container")
{
Props = new { hello = "World" }
};
var result = component.RenderHtml();
Assert.Equal(@"<div id=""container"">[HTML]</div>", result);
}
public void RenderHtmlShouldNotWrapComponentWhenServerSideOnly()
{
var config = new Mock <IReactSiteConfiguration>();
config.Setup(x => x.UseServerSideRendering).Returns(true);
var environment = new Mock <IReactEnvironment>();
environment.Setup(x => x.Execute <bool>("typeof Foo !== 'undefined'")).Returns(true);
environment.Setup(x => x.Execute <string>(@"ReactDOMServer.renderToStaticMarkup(React.createElement(Foo, {""hello"":""World""}))"))
.Returns("[HTML]");
var reactIdGenerator = new Mock <IReactIdGenerator>();
var component = new ReactComponent(environment.Object, config.Object, reactIdGenerator.Object, "Foo", "container")
{
Props = new { hello = "World" },
};
var result = component.RenderHtml(false, true);
Assert.Equal(@"[HTML]", result);
}
public void RenderHtmlShouldNotRenderClientSideAttributes()
{
var environment = new Mock<IReactEnvironment>();
environment.Setup(x => x.Execute<bool>("typeof Foo !== 'undefined'")).Returns(true);
var config = new Mock<IReactSiteConfiguration>();
config.Setup(x => x.UseServerSideRendering).Returns(true);
var component = new ReactComponent(environment.Object, config.Object, "Foo", "container")
{
Props = new { hello = "World" }
};
component.RenderHtml(renderServerOnly: true);
environment.Verify(x => x.Execute<string>(@"ReactDOMServer.renderToStaticMarkup(React.createElement(Foo, {""hello"":""World""}))"));
}
