package org.jooby;
import static org.easymock.EasyMock.eq;
import static org.easymock.EasyMock.expect;
import static org.easymock.EasyMock.isA;
import static org.junit.Assert.assertEquals;
import java.io.ByteArrayInputStream;
import java.io.File;
import java.io.InputStream;
import java.util.Date;
import java.util.Optional;
import org.jooby.test.MockUnit;
import org.junit.Test;
import com.google.common.base.Charsets;
import com.google.common.collect.Lists;
public class ResponseForwardingTest {
@Test
public void unwrap() throws Exception {
new MockUnit(Response.class)
.run(unit -> {
Response rsp = unit.get(Response.class);
assertEquals(rsp, Response.Forwarding.unwrap(new Response.Forwarding(rsp)));
// 2 level
assertEquals(rsp,
Response.Forwarding.unwrap(new Response.Forwarding(new Response.Forwarding(rsp))));
// 3 level
assertEquals(rsp,
Response.Forwarding.unwrap(new Response.Forwarding(new Response.Forwarding(
new Response.Forwarding(rsp)))));
});
}
@Test
public void type() throws Exception {
new MockUnit(Response.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.type()).andReturn(Optional.empty());
expect(rsp.type("json")).andReturn(rsp);
expect(rsp.type(MediaType.js)).andReturn(rsp);
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
assertEquals(Optional.empty(), rsp.type());
assertEquals(rsp, rsp.type("json"));
assertEquals(rsp, rsp.type(MediaType.js));
});
}
@Test
public void header() throws Exception {
new MockUnit(Response.class, Mutant.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.header("h")).andReturn(unit.get(Mutant.class));
})
.run(unit -> {
assertEquals(unit.get(Mutant.class),
new Response.Forwarding(unit.get(Response.class)).header("h"));
});
}
@Test
public void setheader() throws Exception {
Date now = new Date();
new MockUnit(Response.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.header("b", (byte) 1)).andReturn(null);
expect(rsp.header("c", 'c')).andReturn(null);
expect(rsp.header("s", "s")).andReturn(null);
expect(rsp.header("d", now)).andReturn(null);
expect(rsp.header("d", 3d)).andReturn(null);
expect(rsp.header("f", 4f)).andReturn(null);
expect(rsp.header("i", 8)).andReturn(null);
expect(rsp.header("l", 9l)).andReturn(null);
expect(rsp.header("s", (short) 2)).andReturn(null);
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
assertEquals(rsp, rsp.header("b", (byte) 1));
assertEquals(rsp, rsp.header("c", 'c'));
assertEquals(rsp, rsp.header("s", "s"));
assertEquals(rsp, rsp.header("d", now));
assertEquals(rsp, rsp.header("d", 3d));
assertEquals(rsp, rsp.header("f", 4f));
assertEquals(rsp, rsp.header("i", 8));
assertEquals(rsp, rsp.header("l", 9l));
assertEquals(rsp, rsp.header("s", (short) 2));
});
}
@Test
public void cookie() throws Exception {
new MockUnit(Response.class, Cookie.class, Cookie.Definition.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.cookie(unit.get(Cookie.class))).andReturn(null);
expect(rsp.cookie(unit.get(Cookie.Definition.class))).andReturn(null);
expect(rsp.cookie("name", "value")).andReturn(null);
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
assertEquals(rsp, rsp.cookie(unit.get(Cookie.class)));
assertEquals(rsp, rsp.cookie(unit.get(Cookie.Definition.class)));
assertEquals(rsp, rsp.cookie("name", "value"));
});
}
@Test
public void download() throws Exception {
File file = new File("file.ppt");
new MockUnit(Response.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
rsp.download(file);
rsp.download("alias", file);
rsp.download("file.pdf");
rsp.download("alias", "file.pdf");
rsp.download(eq("file.pdf"), isA(InputStream.class));
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
rsp.download(file);
rsp.download("alias", file);
rsp.download("file.pdf");
rsp.download("alias", "file.pdf");
rsp.download("file.pdf", new ByteArrayInputStream(new byte[0]));
});
}
@Test
public void charset() throws Exception {
new MockUnit(Response.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.charset()).andReturn(Charsets.UTF_8);
expect(rsp.charset(Charsets.US_ASCII)).andReturn(null);
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
assertEquals(Charsets.UTF_8, rsp.charset());
assertEquals(rsp, rsp.charset(Charsets.US_ASCII));
});
}
@Test
public void clearCookie() throws Exception {
new MockUnit(Response.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.clearCookie("cookie")).andReturn(null);
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
assertEquals(rsp, rsp.clearCookie("cookie"));
});
}
@Test
public void committed() throws Exception {
new MockUnit(Response.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.committed()).andReturn(true);
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
assertEquals(true, rsp.committed());
});
}
@Test
public void length() throws Exception {
new MockUnit(Response.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.length(10)).andReturn(null);
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
assertEquals(rsp, rsp.length(10));
});
}
@Test
public void redirect() throws Exception {
new MockUnit(Response.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
rsp.redirect("/location");
rsp.redirect(Status.MOVED_PERMANENTLY, "/location");
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
rsp.redirect("/location");
rsp.redirect(Status.MOVED_PERMANENTLY, "/location");
});
}
@Test
public void send() throws Exception {
Result body = Results.ok();
Object obody = new Object();
new MockUnit(Response.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.status()).andReturn(Optional.empty());
expect(rsp.type()).andReturn(Optional.empty());
})
.expect(unit -> {
Response rsp = unit.get(Response.class);
rsp.send(body);
rsp.send(unit.capture(Result.class));
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
rsp.send(body);
rsp.send(obody);
});
}
@Test
public void status() throws Exception {
new MockUnit(Response.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.status()).andReturn(Optional.empty());
expect(rsp.status(200)).andReturn(rsp);
expect(rsp.status(Status.BAD_REQUEST)).andReturn(rsp);
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
assertEquals(Optional.empty(), rsp.status());
assertEquals(rsp, rsp.status(200));
assertEquals(rsp, rsp.status(Status.BAD_REQUEST));
});
}
@Test
public void toStr() throws Exception {
Response rsp = new Response.Forwarding(new ResponseTest.ResponseMock() {
@Override
public String toString() {
return "something something dark";
}
});
assertEquals("something something dark", rsp.toString());
}
@Test
public void singleHeader() throws Exception {
new MockUnit(Response.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.header("h", "v")).andReturn(rsp);
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
assertEquals(rsp, rsp.header("h", "v"));
});
}
@Test
public void arrayHeader() throws Exception {
new MockUnit(Response.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.header("h", "v1", 2)).andReturn(rsp);
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
assertEquals(rsp, rsp.header("h", "v1", 2));
});
}
@Test
public void listHeader() throws Exception {
new MockUnit(Response.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
expect(rsp.header("h", Lists.<Object> newArrayList("v1", 2))).andReturn(rsp);
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
assertEquals(rsp, rsp.header("h", Lists.<Object> newArrayList("v1", 2)));
});
}
@Test
public void end() throws Exception {
new MockUnit(Response.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
rsp.end();
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
rsp.end();
});
}
@Test
public void pushAfter() throws Exception {
new MockUnit(Response.class, Route.After.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
rsp.after(unit.get(Route.After.class));
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
rsp.after(unit.get(Route.After.class));
});
}
@Test
public void pushComplete() throws Exception {
new MockUnit(Response.class, Route.Complete.class)
.expect(unit -> {
Response rsp = unit.get(Response.class);
rsp.complete(unit.get(Route.Complete.class));
})
.run(unit -> {
Response rsp = new Response.Forwarding(unit.get(Response.class));
rsp.complete(unit.get(Route.Complete.class));
});
}
}