package org.jooby;

import com.google.common.escape.Escaper;

import com.google.common.html.HtmlEscapers;

import com.google.common.net.UrlEscapers;

import com.google.inject.Binder;

import com.google.inject.Guice;

import com.google.inject.Injector;

import com.google.inject.Key;

import com.google.inject.Module;

import com.google.inject.ProvisionException;

import com.google.inject.Stage;

import com.google.inject.TypeLiteral;

import com.google.inject.binder.AnnotatedBindingBuilder;

import com.google.inject.binder.AnnotatedConstantBindingBuilder;

import com.google.inject.binder.ConstantBindingBuilder;

import com.google.inject.binder.LinkedBindingBuilder;

import com.google.inject.binder.ScopedBindingBuilder;

import com.google.inject.internal.ProviderMethodsModule;

import com.google.inject.multibindings.Multibinder;

import com.google.inject.multibindings.OptionalBinder;

import com.google.inject.name.Named;

import com.google.inject.name.Names;

import com.google.inject.util.Types;

import com.typesafe.config.Config;

import com.typesafe.config.ConfigFactory;

import com.typesafe.config.ConfigValueFactory;

import org.easymock.EasyMock;

import org.jooby.Session.Definition;

import org.jooby.Session.Store;

import org.jooby.internal.AppPrinter;

import org.jooby.internal.BuiltinParser;

import org.jooby.internal.BuiltinRenderer;

import org.jooby.internal.CookieSessionManager;

import org.jooby.internal.DefaulErrRenderer;

import org.jooby.internal.HttpHandlerImpl;

import org.jooby.internal.ParameterNameProvider;

import org.jooby.internal.RequestScope;

import org.jooby.internal.RouteImpl;

import org.jooby.internal.RouteMetadata;

import org.jooby.internal.ServerSessionManager;

import org.jooby.internal.SessionManager;

import org.jooby.internal.TypeConverters;

import org.jooby.internal.parser.BeanParser;

import org.jooby.internal.parser.DateParser;

import org.jooby.internal.parser.LocalDateParser;

import org.jooby.internal.parser.LocaleParser;

import org.jooby.internal.parser.ParserExecutor;

import org.jooby.internal.parser.StaticMethodParser;

import org.jooby.internal.parser.StringConstructorParser;

import org.jooby.internal.parser.ZonedDateTimeParser;

import org.jooby.internal.ssl.SslContextProvider;

import org.jooby.mvc.GET;

import org.jooby.mvc.POST;

import org.jooby.mvc.Path;

import org.jooby.scope.RequestScoped;

import org.jooby.spi.HttpHandler;

import org.jooby.spi.Server;

import org.jooby.test.MockUnit;

import org.jooby.test.MockUnit.Block;

import org.jooby.funzy.Throwing;

import static org.easymock.EasyMock.*;

import static org.junit.Assert.assertEquals;

import static org.junit.Assert.assertNotNull;

import static org.junit.Assert.assertTrue;

import static org.junit.Assert.fail;

import org.junit.Test;

import org.junit.runner.RunWith;

import org.powermock.core.classloader.annotations.PrepareForTest;

import org.powermock.modules.junit4.PowerMockRunner;

import org.slf4j.Logger;

import org.slf4j.LoggerFactory;

import javax.inject.Provider;

import javax.inject.Singleton;

import javax.net.ssl.SSLContext;

import java.io.File;

import java.nio.charset.Charset;

import java.text.DecimalFormat;

import java.text.NumberFormat;

import java.time.ZoneId;

import java.time.format.DateTimeFormatter;

import java.util.Arrays;

import java.util.Collections;

import java.util.LinkedList;

import java.util.List;

import java.util.Locale;

import java.util.Optional;

import java.util.Set;

import java.util.TimeZone;

import java.util.function.Function;

@RunWith(PowerMockRunner.class)

@PrepareForTest({Jooby.class, Guice.class, TypeConverters.class, Multibinder.class,

OptionalBinder.class, Runtime.class, Thread.class, UrlEscapers.class, HtmlEscapers.class,

LoggerFactory.class})

@SuppressWarnings("unchecked")

public class JoobyTest {

public static class InternalOnStart implements Throwing.Consumer<Registry> {

@Override

public void tryAccept(final Registry value) throws Throwable {

}

}

@Path("/singleton")

@Singleton

public static class SingletonTestRoute {

@GET

@POST

public Object m1() {

return "";

}

}

@Path("/singleton")

@com.google.inject.Singleton

public static class GuiceSingletonTestRoute {

@GET

@POST

public Object m1() {

return "";

}

}

@Path("/proto")

public static class ProtoTestRoute {

@GET

public Object m1() {

return "";

}

}

@SuppressWarnings("rawtypes")

private MockUnit.Block config = unit -> {

ConstantBindingBuilder strCBB = unit.mock(ConstantBindingBuilder.class);

strCBB.to(isA(String.class));

expectLastCall().anyTimes();

AnnotatedConstantBindingBuilder strACBB = unit.mock(AnnotatedConstantBindingBuilder.class);

expect(strACBB.annotatedWith(isA(Named.class))).andReturn(strCBB).anyTimes();

LinkedBindingBuilder<List<String>> listOfString = unit.mock(LinkedBindingBuilder.class);

listOfString.toInstance(isA(List.class));

expectLastCall().anyTimes();

LinkedBindingBuilder<Config> configBinding = unit.mock(LinkedBindingBuilder.class);

configBinding.toInstance(isA(Config.class));

expectLastCall().anyTimes();

AnnotatedBindingBuilder<Config> configAnnotatedBinding = unit

.mock(AnnotatedBindingBuilder.class);

expect(configAnnotatedBinding.annotatedWith(isA(Named.class))).andReturn(configBinding)

.anyTimes();

// root config

configAnnotatedBinding.toInstance(isA(Config.class));

Binder binder = unit.get(Binder.class);

expect(binder.bindConstant()).andReturn(strACBB).anyTimes();

expect(binder.bind(Config.class)).andReturn(configAnnotatedBinding).anyTimes();

expect(binder.bind(Key.get(Types.listOf(String.class), Names.named("cors.allowedHeaders"))))

.andReturn((LinkedBindingBuilder) listOfString);

expect(binder.bind(Key.get(Types.listOf(String.class), Names.named("cors.allowedMethods"))))

.andReturn((LinkedBindingBuilder) listOfString);

};

private MockUnit.Block env = unit -> {

Binder binder = unit.get(Binder.class);

AnnotatedBindingBuilder<Env> binding = unit.mock(AnnotatedBindingBuilder.class);

binding.toInstance(isA(Env.class));

expect(binder.bind(Env.class)).andReturn(binding);

};

private MockUnit.Block ssl = unit -> {

Binder binder = unit.get(Binder.class);

ScopedBindingBuilder sbbSsl = unit.mock(ScopedBindingBuilder.class);

AnnotatedBindingBuilder<SSLContext> binding = unit.mock(AnnotatedBindingBuilder.class);

expect(binding.toProvider(SslContextProvider.class)).andReturn(sbbSsl);

expect(binder.bind(SSLContext.class)).andReturn(binding);

};

private MockUnit.Block classInfo = unit -> {

Binder binder = unit.get(Binder.class);

AnnotatedBindingBuilder<ParameterNameProvider> binding = unit

.mock(AnnotatedBindingBuilder.class);

binding.toInstance(isA(RouteMetadata.class));

expect(binder.bind(ParameterNameProvider.class)).andReturn(binding);

};

private MockUnit.Block charset = unit -> {

Binder binder = unit.get(Binder.class);

AnnotatedBindingBuilder<Charset> binding = unit.mock(AnnotatedBindingBuilder.class);

binding.toInstance(isA(Charset.class));

expect(binder.bind(Charset.class)).andReturn(binding);

};

private MockUnit.Block locale = unit -> {

Binder binder = unit.get(Binder.class);

AnnotatedBindingBuilder<Locale> binding = unit.mock(AnnotatedBindingBuilder.class);

binding.toInstance(isA(Locale.class));

AnnotatedBindingBuilder<List<Locale>> bindings = unit.mock(AnnotatedBindingBuilder.class);

bindings.toInstance(isA(List.class));

expect(binder.bind(Locale.class)).andReturn(binding);

TypeLiteral<List<Locale>> localeType = (TypeLiteral<List<Locale>>) TypeLiteral

.get(Types.listOf(Locale.class));

expect(binder.bind(localeType)).andReturn(bindings);

};

private MockUnit.Block zoneId = unit -> {

Binder binder = unit.get(Binder.class);

AnnotatedBindingBuilder<ZoneId> binding = unit.mock(AnnotatedBindingBuilder.class);

binding.toInstance(isA(ZoneId.class));

expect(binder.bind(ZoneId.class)).andReturn(binding);

};

private MockUnit.Block timeZone = unit -> {

Binder binder = unit.get(Binder.class);

AnnotatedBindingBuilder<TimeZone> binding = unit.mock(AnnotatedBindingBuilder.class);

binding.toInstance(isA(TimeZone.class));

expect(binder.bind(TimeZone.class)).andReturn(binding);

};

private MockUnit.Block dateTimeFormatter = unit -> {

Binder binder = unit.get(Binder.class);

AnnotatedBindingBuilder<DateTimeFormatter> binding = unit.mock(AnnotatedBindingBuilder.class);

binding.toInstance(isA(DateTimeFormatter.class));

expect(binder.bind(DateTimeFormatter.class)).andReturn(binding);

};

private MockUnit.Block numberFormat = unit -> {

Binder binder = unit.get(Binder.class);

AnnotatedBindingBuilder<NumberFormat> binding = unit.mock(AnnotatedBindingBuilder.class);

binding.toInstance(isA(NumberFormat.class));

expect(binder.bind(NumberFormat.class)).andReturn(binding);

};

private MockUnit.Block decimalFormat = unit -> {

Binder binder = unit.get(Binder.class);

AnnotatedBindingBuilder<DecimalFormat> binding = unit.mock(AnnotatedBindingBuilder.class);

binding.toInstance(isA(DecimalFormat.class));

expect(binder.bind(DecimalFormat.class)).andReturn(binding);

};

private MockUnit.Block renderers = unit -> {

Multibinder<Renderer> multibinder = unit.mock(Multibinder.class);

Binder binder = unit.get(Binder.class);

unit.mockStatic(Multibinder.class);

expect(Multibinder.newSetBinder(binder, Renderer.class)).andReturn(multibinder);

LinkedBindingBuilder<Renderer> formatAsset = unit.mock(LinkedBindingBuilder.class);

formatAsset.toInstance(BuiltinRenderer.asset);

LinkedBindingBuilder<Renderer> formatByteArray = unit.mock(LinkedBindingBuilder.class);

formatByteArray.toInstance(BuiltinRenderer.bytes);

LinkedBindingBuilder<Renderer> formatByteBuffer = unit.mock(LinkedBindingBuilder.class);

formatByteBuffer.toInstance(BuiltinRenderer.byteBuffer);

LinkedBindingBuilder<Renderer> file = unit.mock(LinkedBindingBuilder.class);

file.toInstance(BuiltinRenderer.file);

LinkedBindingBuilder<Renderer> formatStream = unit.mock(LinkedBindingBuilder.class);

formatStream.toInstance(BuiltinRenderer.stream);

LinkedBindingBuilder<Renderer> reader = unit.mock(LinkedBindingBuilder.class);

reader.toInstance(BuiltinRenderer.reader);

LinkedBindingBuilder<Renderer> charBuffer = unit.mock(LinkedBindingBuilder.class);

charBuffer.toInstance(BuiltinRenderer.charBuffer);

LinkedBindingBuilder<Renderer> fchannel = unit.mock(LinkedBindingBuilder.class);

fchannel.toInstance(BuiltinRenderer.fileChannel);

LinkedBindingBuilder<Renderer> err = unit.mock(LinkedBindingBuilder.class);

err.toInstance(isA(DefaulErrRenderer.class));

LinkedBindingBuilder<Renderer> formatAny = unit.mock(LinkedBindingBuilder.class);

formatAny.toInstance(BuiltinRenderer.text);

expect(multibinder.addBinding()).andReturn(formatAsset);

expect(multibinder.addBinding()).andReturn(formatByteArray);

expect(multibinder.addBinding()).andReturn(formatByteBuffer);

expect(multibinder.addBinding()).andReturn(file);

expect(multibinder.addBinding()).andReturn(charBuffer);

expect(multibinder.addBinding()).andReturn(formatStream);

expect(multibinder.addBinding()).andReturn(reader);

expect(multibinder.addBinding()).andReturn(fchannel);

expect(multibinder.addBinding()).andReturn(err);

expect(multibinder.addBinding()).andReturn(formatAny);

};

private MockUnit.Block routes = unit -> {

Multibinder<Route.Definition> multibinder = unit.mock(Multibinder.class);

Binder binder = unit.get(Binder.class);

expect(Multibinder.newSetBinder(binder, Route.Definition.class)).andReturn(multibinder);

};

private MockUnit.Block routeHandler = unit -> {

ScopedBindingBuilder routehandlerscope = unit.mock(ScopedBindingBuilder.class);

routehandlerscope.in(Singleton.class);

AnnotatedBindingBuilder<HttpHandler> routehandlerbinding = unit

.mock(AnnotatedBindingBuilder.class);

expect(routehandlerbinding.to(HttpHandlerImpl.class)).andReturn(routehandlerscope);

expect(unit.get(Binder.class).bind(HttpHandler.class)).andReturn(routehandlerbinding);

};

private MockUnit.Block webSockets = unit -> {

Multibinder<WebSocket.Definition> multibinder = unit.mock(Multibinder.class);

Binder binder = unit.get(Binder.class);

expect(Multibinder.newSetBinder(binder, WebSocket.Definition.class)).andReturn(multibinder);

};

private MockUnit.Block tmpdir = unit -> {

Binder binder = unit.get(Binder.class);

LinkedBindingBuilder<File> instance = unit.mock(LinkedBindingBuilder.class);

instance.toInstance(isA(File.class));

AnnotatedBindingBuilder<File> named = unit.mock(AnnotatedBindingBuilder.class);

expect(named.annotatedWith(Names.named("application.tmpdir"))).andReturn(instance);

expect(binder.bind(java.io.File.class)).andReturn(named);

};

private MockUnit.Block err = unit -> {

Binder binder = unit.get(Binder.class);

LinkedBindingBuilder<Err.Handler> ehlbb = unit.mock(LinkedBindingBuilder.class);

ehlbb.toInstance(isA(Err.DefHandler.class));

Multibinder<Err.Handler> multibinder = unit.mock(Multibinder.class);

expect(Multibinder.newSetBinder(binder, Err.Handler.class)).andReturn(multibinder);

expect(multibinder.addBinding()).andReturn(ehlbb);

};

private MockUnit.Block session = unit -> {

Binder binder = unit.get(Binder.class);

AnnotatedBindingBuilder<SessionManager> smABB = unit.mock(AnnotatedBindingBuilder.class);

expect(smABB.to(ServerSessionManager.class)).andReturn(smABB);

smABB.asEagerSingleton();

ScopedBindingBuilder ssSBB = unit.mock(ScopedBindingBuilder.class);

ssSBB.asEagerSingleton();

AnnotatedBindingBuilder<Store> ssABB = unit.mock(AnnotatedBindingBuilder.class);

expect(ssABB.to(Session.Mem.class)).andReturn(ssSBB);

expect(binder.bind(SessionManager.class)).andReturn(smABB);

expect(binder.bind(Session.Store.class)).andReturn(ssABB);

AnnotatedBindingBuilder<Session.Definition> sdABB = unit.mock(AnnotatedBindingBuilder.class);

expect(sdABB.toProvider(isA(com.google.inject.Provider.class))).andReturn(sdABB);

sdABB.asEagerSingleton();

expect(binder.bind(Session.Definition.class)).andReturn(sdABB);

};

private MockUnit.Block boot = unit -> {

Module module = unit.captured(Module.class).iterator().next();

module.configure(unit.get(Binder.class));

unit.captured(Runnable.class).get(0).run();

};

private MockUnit.Block requestScope = unit -> {

Binder binder = unit.get(Binder.class);

AnnotatedBindingBuilder<RequestScope> reqscopebinding = unit

.mock(AnnotatedBindingBuilder.class);

reqscopebinding.toInstance(isA(RequestScope.class));

expect(binder.bind(RequestScope.class)).andReturn(reqscopebinding);

binder.bindScope(eq(RequestScoped.class), isA(RequestScope.class));

ScopedBindingBuilder reqscope = unit.mock(ScopedBindingBuilder.class);

reqscope.in(RequestScoped.class);

reqscope.in(RequestScoped.class);

reqscope.in(RequestScoped.class);

AnnotatedBindingBuilder<Request> reqbinding = unit.mock(AnnotatedBindingBuilder.class);

expect(reqbinding.toProvider(isA(Provider.class))).andReturn(reqscope);

expect(binder.bind(Request.class)).andReturn(reqbinding);

AnnotatedBindingBuilder<Route.Chain> chainbinding = unit.mock(AnnotatedBindingBuilder.class);

expect(chainbinding.toProvider(isA(Provider.class))).andReturn(reqscope);

expect(binder.bind(Route.Chain.class)).andReturn(chainbinding);

ScopedBindingBuilder rspscope = unit.mock(ScopedBindingBuilder.class);

rspscope.in(RequestScoped.class);

AnnotatedBindingBuilder<Response> rspbinding = unit.mock(AnnotatedBindingBuilder.class);

expect(rspbinding.toProvider(isA(Provider.class))).andReturn(rspscope);

expect(binder.bind(Response.class)).andReturn(rspbinding);

ScopedBindingBuilder sessionscope = unit.mock(ScopedBindingBuilder.class);

sessionscope.in(RequestScoped.class);

AnnotatedBindingBuilder<Session> sessionbinding = unit.mock(AnnotatedBindingBuilder.class);

expect(sessionbinding.toProvider(isA(Provider.class)))

.andReturn(sessionscope);

expect(binder.bind(Session.class)).andReturn(sessionbinding);

AnnotatedBindingBuilder<Sse> sseb = unit.mock(AnnotatedBindingBuilder.class);

expect(sseb.toProvider(isA(Provider.class)))

.andReturn(reqscope);

expect(binder.bind(Sse.class)).andReturn(sseb);

};

private MockUnit.Block params = unit -> {

Binder binder = unit.get(Binder.class);

AnnotatedBindingBuilder<ParserExecutor> parambinding = unit

.mock(AnnotatedBindingBuilder.class);

parambinding.in(Singleton.class);

expect(binder.bind(ParserExecutor.class)).andReturn(parambinding);

Multibinder<Parser> multibinder = unit.mock(Multibinder.class, true);

for (Parser parser : BuiltinParser.values()) {

LinkedBindingBuilder<Parser> converterBinding = unit.mock(LinkedBindingBuilder.class);

converterBinding.toInstance(parser);

expect(multibinder.addBinding()).andReturn(converterBinding);

}

@SuppressWarnings("rawtypes")

Class[] parserClasses = {

DateParser.class,

LocalDateParser.class,

ZonedDateTimeParser.class,

LocaleParser.class,

StaticMethodParser.class,

StaticMethodParser.class,

StaticMethodParser.class,

StringConstructorParser.class,

BeanParser.class

};

for (Class<? extends Parser> converter : parserClasses) {

LinkedBindingBuilder<Parser> converterBinding = unit.mock(LinkedBindingBuilder.class);

converterBinding.toInstance(isA(converter));

expect(multibinder.addBinding()).andReturn(converterBinding);

}

expect(Multibinder.newSetBinder(binder, Parser.class)).andReturn(multibinder);

};

private MockUnit.Block shutdown = unit -> {

unit.mockStatic(Runtime.class);

Thread thread = unit.mockConstructor(Thread.class, new Class<?>[]{Runnable.class},

unit.capture(Runnable.class));

Runtime runtime = unit.mock(Runtime.class);

expect(Runtime.getRuntime()).andReturn(runtime).times(2);

runtime.addShutdownHook(thread);

expect(runtime.availableProcessors()).andReturn(1);

};

private MockUnit.Block guice = unit -> {

Server server = unit.mock(Server.class);

server.start();

server.join();

server.stop();

ScopedBindingBuilder serverScope = unit.mock(ScopedBindingBuilder.class);

serverScope.in(Singleton.class);

expectLastCall().times(0, 1);

AnnotatedBindingBuilder<Server> serverBinding = unit.mock(AnnotatedBindingBuilder.class);

expect(serverBinding.to(isA(Class.class))).andReturn(serverScope).times(0, 1);

Binder binder = unit.get(Binder.class);

binder.install(anyObject(ProviderMethodsModule.class));

EasyMock.expectLastCall().atLeastOnce();

expect(binder.bind(Server.class)).andReturn(serverBinding).times(0, 1);

// ConfigOrigin configOrigin = unit.mock(ConfigOrigin.class);

// expect(configOrigin.description()).andReturn("test.conf, mock.conf").times(0, 1);

Config config = unit.mock(Config.class);

expect(config.getString("application.env")).andReturn("dev");

expect(config.hasPath("server.join")).andReturn(true);

expect(config.getBoolean("server.join")).andReturn(true);

unit.registerMock(Config.class, config);

// expect(config.origin()).andReturn(configOrigin).times(0, 1);

Injector injector = unit.mock(Injector.class);

expect(injector.getInstance(Server.class)).andReturn(server).times(1, 2);

expect(injector.getInstance(Config.class)).andReturn(config);

expect(injector.getInstance(Route.KEY)).andReturn(Collections.emptySet());

expect(injector.getInstance(WebSocket.KEY)).andReturn(Collections.emptySet());

injector.injectMembers(isA(Jooby.class));

unit.registerMock(Injector.class, injector);

AppPrinter printer = unit.constructor(AppPrinter.class)

.args(Set.class, Set.class, Config.class)

.build(isA(Set.class), isA(Set.class), isA(Config.class));

printer.printConf(isA(Logger.class), eq(config));

unit.mockStatic(Guice.class);

expect(Guice.createInjector(eq(Stage.DEVELOPMENT), unit.capture(Module.class))).andReturn(

injector);

unit.mockStatic(OptionalBinder.class);

TypeConverters tc = unit.mockConstructor(TypeConverters.class);

tc.configure(binder);

};

@Test

public void applicationSecret() throws Exception {

new MockUnit(Binder.class)

.expect(

unit -> {

Server server = unit.mock(Server.class);

server.start();

server.join();

server.stop();

ScopedBindingBuilder serverScope = unit.mock(ScopedBindingBuilder.class);

serverScope.in(Singleton.class);

expectLastCall().times(0, 1);

AnnotatedBindingBuilder<Server> serverBinding = unit

.mock(AnnotatedBindingBuilder.class);

expect(serverBinding.to(isA(Class.class))).andReturn(serverScope).times(0, 1);

Binder binder = unit.get(Binder.class);

binder.install(anyObject(ProviderMethodsModule.class));

expect(binder.bind(Server.class)).andReturn(serverBinding).times(0, 1);

// ConfigOrigin configOrigin = unit.mock(ConfigOrigin.class);

// expect(configOrigin.description()).andReturn("test.conf, mock.conf").times(0, 1);

Config config = unit.mock(Config.class);

expect(config.getString("application.env")).andReturn("dev");

expect(config.hasPath("server.join")).andReturn(true);

expect(config.getBoolean("server.join")).andReturn(true);

unit.registerMock(Config.class, config);

// expect(config.origin()).andReturn(configOrigin).times(0, 1);

AppPrinter printer = unit.constructor(AppPrinter.class)

.args(Set.class, Set.class, Config.class)

.build(isA(Set.class), isA(Set.class), isA(Config.class));

printer.printConf(isA(Logger.class), eq(config));

Injector injector = unit.mock(Injector.class);

expect(injector.getInstance(Server.class)).andReturn(server).times(1, 2);

expect(injector.getInstance(Config.class)).andReturn(config);

expect(injector.getInstance(Route.KEY)).andReturn(Collections.emptySet());

expect(injector.getInstance(WebSocket.KEY)).andReturn(Collections.emptySet());

injector.injectMembers(isA(Jooby.class));

unit.mockStatic(Guice.class);

expect(Guice.createInjector(eq(Stage.PRODUCTION), unit.capture(Module.class)))

.andReturn(

injector);

unit.mockStatic(OptionalBinder.class);

TypeConverters tc = unit.mockConstructor(TypeConverters.class);

tc.configure(binder);

})

.expect(shutdown)

.expect(config)

.expect(internalOnStart(false))

.expect(ssl)

.expect(env)

.expect(classInfo)

.expect(charset)

.expect(locale)

.expect(zoneId)

.expect(timeZone)

.expect(dateTimeFormatter)

.expect(numberFormat)

.expect(decimalFormat)

.expect(renderers)

.expect(session)

.expect(routes)

.expect(routeHandler)

.expect(params)

.expect(requestScope)

.expect(webSockets)

.expect(tmpdir)

.expect(err)

.run(unit -> {

Jooby jooby = new Jooby();

jooby.use(ConfigFactory.empty()

.withValue("application.env", ConfigValueFactory.fromAnyRef("prod"))

.withValue("application.secret", ConfigValueFactory.fromAnyRef("234")));

jooby.start();

}, boot);

}

@Test

public void defaults() throws Exception {

new MockUnit(Binder.class)

.expect(guice)

.expect(internalOnStart(false))

.expect(shutdown)

.expect(config)

.expect(env)

.expect(classInfo)

.expect(ssl)

.expect(charset)

.expect(locale)

.expect(zoneId)

.expect(timeZone)

.expect(dateTimeFormatter)

.expect(numberFormat)

.expect(decimalFormat)

.expect(renderers)

.expect(session)

.expect(routes)

.expect(routeHandler)

.expect(params)

.expect(requestScope)

.expect(webSockets)

.expect(tmpdir)

.expect(err)

.run(unit -> {

Jooby jooby = new Jooby();

assertEquals(false, jooby.isStarted());

jooby.start();

assertEquals(true, jooby.isStarted());

}, boot);

}

@Test

public void requireShouldHideProvisionExceptionWhenCauseIsErr() throws Exception {

new MockUnit(Binder.class)

.expect(guice)

.expect(internalOnStart(false))

.expect(shutdown)

.expect(config)

.expect(env)

.expect(classInfo)

.expect(ssl)

.expect(charset)

.expect(locale)

.expect(zoneId)

.expect(timeZone)

.expect(dateTimeFormatter)

.expect(numberFormat)

.expect(decimalFormat)

.expect(renderers)

.expect(session)

.expect(routes)

.expect(routeHandler)

.expect(params)

.expect(requestScope)

.expect(webSockets)

.expect(tmpdir)

.expect(err)

.expect(unit -> {

Injector injector = unit.get(Injector.class);

ProvisionException x = new ProvisionException("intentional error", new Err(Status.BAD_REQUEST));

expect(injector.getInstance(Key.get(Object.class))).andThrow(x);

})

.run(unit -> {

Jooby jooby = new Jooby();

jooby.start();

try {

jooby.require(Object.class);

fail("Should throw Err");

} catch (Err x) {

assertEquals(400, x.statusCode());

}

}, boot);

}

@Test

public void requireShouldNotHideProvisionExceptionWhenCauseIsNotErr() throws Exception {

new MockUnit(Binder.class)

.expect(guice)

.expect(internalOnStart(false))

.expect(shutdown)

.expect(config)

.expect(env)

.expect(classInfo)

.expect(ssl)

.expect(charset)

.expect(locale)

.expect(zoneId)

.expect(timeZone)

.expect(dateTimeFormatter)

.expect(numberFormat)

.expect(decimalFormat)

.expect(renderers)

.expect(session)

.expect(routes)

.expect(routeHandler)

.expect(params)

.expect(requestScope)

.expect(webSockets)

.expect(tmpdir)

.expect(err)

.expect(unit -> {

Injector injector = unit.get(Injector.class);

ProvisionException x = new ProvisionException("intentional error");

expect(injector.getInstance(Key.get(Object.class))).andThrow(x);

})

.run(unit -> {

Jooby jooby = new Jooby();

jooby.start();

try {

jooby.require(Object.class);

fail("Should throw Err");

} catch (ProvisionException x) {

}

}, boot);

}

@Test

public void withInternalOnStart() throws Exception {

new MockUnit(Binder.class)

.expect(guice)

.expect(internalOnStart(true))

.expect(shutdown)

.expect(config)

.expect(env)

.expect(classInfo)

.expect(ssl)

.expect(charset)

.expect(locale)

.expect(zoneId)

.expect(timeZone)

.expect(dateTimeFormatter)

.expect(numberFormat)

.expect(decimalFormat)

.expect(renderers)

.expect(session)

.expect(routes)

.expect(routeHandler)

.expect(params)

.expect(requestScope)

.expect(webSockets)

.expect(tmpdir)

.expect(err)

.run(unit -> {

Jooby jooby = new Jooby();

assertEquals(false, jooby.isStarted());

jooby.start();

assertEquals(true, jooby.isStarted());

}, boot);

}

@Test

public void requireByNameAndTypeLiteralShouldWork() throws Exception {

Object someVerySpecificObject = new Object();

new MockUnit(Binder.class)

.expect(guice)

.expect(internalOnStart(false))

.expect(shutdown)

.expect(config)

.expect(env)

.expect(classInfo)

.expect(ssl)

.expect(charset)

.expect(locale)

.expect(zoneId)

.expect(timeZone)

.expect(dateTimeFormatter)

.expect(numberFormat)

.expect(decimalFormat)

.expect(renderers)

.expect(session)

.expect(routes)

.expect(routeHandler)

.expect(params)

.expect(requestScope)

.expect(webSockets)

.expect(tmpdir)

.expect(err)

.expect(unit -> {

Injector injector = unit.get(Injector.class);

expect(injector.getInstance(Key.get(Object.class, Names.named("foo")))).andReturn(someVerySpecificObject);

})

.run(unit -> {

Jooby jooby = new Jooby();

jooby.start();

Object actual = jooby.require("foo", TypeLiteral.get(Object.class));

assertEquals(actual, someVerySpecificObject);

}, boot);

}

private Block internalOnStart(final boolean b) {

return unit -> {

Config conf = unit.get(Config.class);

expect(conf.hasPath("jooby.internal.onStart")).andReturn(b);

if (b) {

expect(conf.getString("jooby.internal.onStart"))

.andReturn(InternalOnStart.class.getName());

}

};

}

@Test

public void cookieSession() throws Exception {

new MockUnit(Binder.class)

.expect(guice)

.expect(shutdown)

.expect(config)

.expect(env)

.expect(classInfo)

.expect(ssl)

.expect(charset)

.expect(locale)

.expect(zoneId)

.expect(timeZone)

.expect(dateTimeFormatter)

.expect(numberFormat)

.expect(decimalFormat)

.expect(renderers)

.expect(unit -> {

Binder binder = unit.get(Binder.class);

AnnotatedBindingBuilder<SessionManager> smABB = unit.mock(AnnotatedBindingBuilder.class);

expect(smABB.to(CookieSessionManager.class)).andReturn(smABB);

smABB.asEagerSingleton();

expect(binder.bind(SessionManager.class)).andReturn(smABB);

AnnotatedBindingBuilder<Session.Definition> sdABB = unit

.mock(AnnotatedBindingBuilder.class);

expect(sdABB.toProvider(isA(com.google.inject.Provider.class))).andReturn(sdABB);

sdABB.asEagerSingleton();

expect(binder.bind(Session.Definition.class)).andReturn(sdABB);

})

.expect(routes)

.expect(routeHandler)

.expect(params)

.expect(requestScope)

.expect(webSockets)

.expect(tmpdir)

.expect(err)

.expect(internalOnStart(false))

.run(unit -> {

Jooby jooby = new Jooby();

jooby.use(ConfigFactory.empty()

.withValue("application.secret", ConfigValueFactory.fromAnyRef("234")));

jooby.cookieSession();

jooby.start();

}, boot);

}

@Test

public void cookieSessionShouldFailWhenApplicationSecretIsnotPresent() throws Throwable {

Jooby jooby = new Jooby();

jooby.cookieSession();

jooby.start();

}

@Test

public void onStartStopCallback() throws Exception {

new MockUnit(Binder.class, Throwing.Runnable.class)

.expect(guice)

.expect(shutdown)

.expect(config)

.expect(env)

.expect(classInfo)

.expect(ssl)

.expect(charset)

.expect(locale)

.expect(zoneId)

.expect(timeZone)

.expect(dateTimeFormatter)

.expect(numberFormat)

.expect(decimalFormat)

.expect(renderers)

.expect(session)

.expect(routes)

.expect(routeHandler)

.expect(params)

.expect(requestScope)

.expect(webSockets)

.expect(tmpdir)

.expect(err)

.expect(internalOnStart(false))

.expect(unit -> {

unit.get(Throwing.Runnable.class).run();

unit.get(Throwing.Runnable.class).run();

})

.run(unit -> {

Jooby app = new Jooby()

.onStart(unit.get(Throwing.Runnable.class))

.onStop(unit.get(Throwing.Runnable.class));

app.start();

app.stop();

}, boot);

}

@Test(expected = IllegalStateException.class)

public void appDidnStart() throws Exception {

new Jooby().require(Object.class);

}

@Test

public void onStopCallbackLogError() throws Exception {

new MockUnit(Binder.class, Throwing.Runnable.class)

.expect(guice)

.expect(shutdown)

.expect(config)