public void testRelease() {
{
try {
st.release(new PSI(st, "g1", "i1", 823502L, 10));
} catch (EmptyStackException e) {
}
}
{
PSI psi0 = st.getStackItem("g2", "i0");
PSI psi1 = st.getStackItem("g2", "i1");
st.getStackItem("g2", "i2");
PSI psi3 = st.getStackItem("g2", "i3");
Mockery ctx = new Mockery();
final Log log = ctx.mock(Log.class);
LogFactory lf = new ServerImplTest.TestLogFactory(log);
Api api = new Api();
api.setIntfImplementor(LogFactory.class, lf);
ApiStack.pushApi(api);
try {
psi3.close();
ctx.checking(
new Expectations() {
{
one(log).error(with(any(String.class)));
}
});
psi1.close(); // must be error reported
ctx.assertIsSatisfied();
psi0.close(); // no errors
} finally {
ApiStack.popApi();
}
}
}
@SuppressWarnings("unchecked")
@Override
protected void setUp() throws Exception {
// Build the properties
props = new HashMap<String, String>();
props.put("CountryCode", "US");
props.put("CountryCode3", "USA");
props.put("CountryName", "United States");
props.put("Region", "NY");
props.put("Region2", "New York");
props.put("City", "New York");
props.put("PostalCode", "10004");
props.put("Latitude", "40.6888");
props.put("Longitude", "74.0203");
props.put("DmaCode", "501");
props.put("AreaCode", "212");
// Build the String
final String SEPARATOR = "\t";
final String NEWLINE = "\n";
String testString = SEPARATOR + NEWLINE;
for (Map.Entry<String, String> en : props.entrySet()) {
testString += en.getKey() + SEPARATOR + en.getValue() + NEWLINE;
}
testS = testString;
mockery = new Mockery();
httpClient = mockery.mock(LimeHttpClient.class);
geoCodeURL = mockery.mock(Provider.class);
geo = new GeocoderImpl(geoCodeURL, Providers.of(httpClient));
}
@Test
public void testFlattenSelectionJMock2() throws Exception {
final IAssetType type1 = mockery.mock(IAssetType.class, "type1");
final IAssetType type2 = mockery.mock(IAssetType.class, "type2");
final IAttributeDefinition token0 = mockery.mock(IAttributeDefinition.class, "Token0");
final IAttributeDefinition token1 = mockery.mock(IAttributeDefinition.class, "Token1");
List<IAttributeDefinition> orig = new LinkedList<IAttributeDefinition>();
orig.add(token1);
mockery.checking(
new Expectations() {
{
allowing(token1).getAssetType();
will(returnValue(type2));
one(type2).isA(type1);
will(returnValue(true));
one(type1).isA(type1);
will(returnValue(false));
one(type1).getAttributeDefinition("Token1");
will(returnValue(token1));
allowing(token1).getBase();
will(returnValue(token0));
one(token1).getName();
will(returnValue("Token1"));
one(token0).getAssetType();
will(returnValue(type1));
}
});
AttributeSelection res = flattenSelection(type1, orig);
assertEqualsAsSet(null, res, Arrays.asList(token1));
}
@Test
public void exceptionInProtocolClosesClientSession() throws IOException {
i = 0;
final Protocol protocol =
new Protocol() {
public void init(ClientSession session) {}
public void parseFirst(InputStream message) throws IOException {}
public void parsePacket(InputStream message) throws IOException {
i++;
throw new IOException("Test");
}
};
context.checking(
new Expectations() {
{
oneOf(mockedClient).close();
}
});
prot.setCurrentProtocol(protocol);
ByteArrayOutputStream out = new ByteArrayOutputStream();
CData.writeU16(out, 2);
CData.writeU16(out, 1337);
prot.messageReceived(mockedClient, new ByteArrayInputStream(out.toByteArray()));
assertEquals(1, i);
context.assertIsSatisfied();
}
@SuppressWarnings("unchecked")
protected ParameterService getParameterService() {
final ParameterService parameterService = context.mock(ParameterService.class);
context.checking(
new Expectations() {
{
allowing(parameterService)
.parameterExists(with(any(Class.class)), with(any(String.class)));
will(returnValue(true));
allowing(parameterService)
.getParameterValueAsBoolean(
ProtocolDocument.class, Constants.ENABLE_PROTOCOL_TO_AWARD_LINK);
will(returnValue(true));
allowing(parameterService)
.getParameterValueAsBoolean(
ProtocolDocument.class, Constants.ENABLE_PROTOCOL_TO_DEV_PROPOSAL_LINK);
will(returnValue(true));
allowing(parameterService)
.getParameterValueAsBoolean(
ProtocolDocument.class, Constants.ENABLE_PROTOCOL_TO_PROPOSAL_LINK);
will(returnValue(true));
}
});
return parameterService;
}
@Test
public void all_valid_exits_are_retrieveable() {
final Exit exit1 = mockery.mock(Exit.class, "exit1");
final Exit exit2 = mockery.mock(Exit.class, "exit2");
mockery.checking(
new Expectations() {
{
allowing(exit1).visible();
will(returnValue(true));
ignoring(exit1);
allowing(exit2).visible();
will(returnValue(true));
ignoring(exit2);
}
});
List<Exit> exits = new ArrayList<Exit>();
exits.add(exit1);
exits.add(exit2);
Location l = createLocation();
l.addExit(exit1);
l.addExit(exit2);
assertEquals(exits, l.visibleExits());
}
@Test
public void available_items_text_includes_only_visible_items() {
final Item visibleItem = mockery.mock(Item.class, "visible item");
final Item invisibleItem = mockery.mock(Item.class, "invisible item");
mockery.checking(
new Expectations() {
{
allowing(visibleItem).visible();
will(returnValue(true));
allowing(visibleItem).countableNounPrefix();
will(returnValue("a"));
allowing(visibleItem).midSentenceCasedName();
will(returnValue("visible item"));
ignoring(visibleItem);
allowing(invisibleItem).visible();
will(returnValue(false));
allowing(invisibleItem).midSentenceCasedName();
will(returnValue("invisible item"));
ignoring(invisibleItem);
}
});
Location l = new Location("", "Location description.", null, null);
l.addItem(visibleItem);
l.addItem(invisibleItem);
assertEquals("There is a visible item here.\n", l.availableItemsText());
}
public void testReadWithNoCharsetAndStreamDoesntSupportMarkAssumesUTF8() throws Exception {
final byte[] b = new byte[8192];
final int off = 0;
final int len = 8192;
final InputStream stream = context.mock(InputStream.class);
context.checking(
new Expectations() {
{
oneOf(stream).markSupported();
will(returnValue(false));
// Read a single byte/char to check for BOM
oneOf(stream).read(b, off, len);
will(returnValue(1));
oneOf(stream).available();
will(returnValue(-1));
// Read content, but return empty
oneOf(stream).read(b, off, len);
will(returnValue(-1));
// Close stream
oneOf(stream).close();
}
});
String result = IOUtil.read(stream);
assertNotNull(result);
// Returned one single 0 byte because we allowed reading of one...
assertEquals(1, result.length());
context.assertIsSatisfied();
}
public void testReadWithNoCharsetAndMarkSupportedSniffsCharset() throws Exception {
final byte[] b = new byte[8192];
final int off = 0;
final int len = 8192;
final InputStream stream = context.mock(InputStream.class);
context.checking(
new Expectations() {
{
// charset sniffing
oneOf(stream).markSupported();
will(returnValue(true));
oneOf(stream).mark(8000);
oneOf(stream).read(new byte[8000], 0, 8000);
will(returnValue(-1));
oneOf(stream).reset();
oneOf(stream).reset();
// Now do the reading
oneOf(stream).read(b, off, len);
// FIXME Read back actual bytes/chars/etc
will(throwException(new IOException("")));
oneOf(stream).close();
}
});
IOUtil.read(stream);
context.assertIsSatisfied();
}
@Test
public void permissions() {
context.checking(
new Expectations() {
{
one(repository).get(1);
will(returnValue(new Group()));
one(roleManager).isAdministrator();
will(returnValue(true));
one(categoryRepository).getAllCategories();
will(returnValue(new ArrayList<Category>()));
one(repository).getAllGroups();
will(returnValue(new ArrayList<Group>()));
one(mockResult).include("group", new Group());
one(mockResult).include("groups", new ArrayList<Group>());
one(mockResult).include("categories", new ArrayList<Category>());
// TODO: fix PermOption one(mockResult).include("permissions", new
// PermissionOptions());
}
});
controller.permissions(1);
context.assertIsSatisfied();
}
@Test
public void basic() throws IOException {
final Object[] tst = new Object[] {"test1", "test2"};
context.checking(
new Expectations() {
{
oneOf(node).getProperty("test");
will(returnValue(tst));
oneOf(model).pushNode("test", -1);
will(returnValue(node));
oneOf(model).pushNode("0", 0);
will(returnValue(node));
oneOf(template).render(model);
oneOf(model).popNode();
oneOf(model).pushNode("1", 1);
will(returnValue(node));
oneOf(template).render(model);
oneOf(model).popNode();
oneOf(model).popNode();
}
});
element = new ArrayElement(property.getName(), template);
element.render(model);
context.assertIsSatisfied();
}
@Test
public void testCustomComponentFactoryCanBeSpecified() {
Reader script =
new StringReader(
"A = org.picocontainer.script.testmodel.A\n"
+ "container(:component_adapter_factory => $assembly_scope) {\n"
+ " component(A)\n"
+ "}");
final A a = new A();
final ComponentFactory componentFactory = mockery.mock(ComponentFactory.class);
mockery.checking(
new Expectations() {
{
one(componentFactory)
.createComponentAdapter(
with(any(ComponentMonitor.class)),
with(any(LifecycleStrategy.class)),
with(any(Properties.class)),
with(same(A.class)),
with(same(A.class)),
with(aNull(Parameter[].class)));
will(
returnValue(
new InstanceAdapter<A>(
A.class, a, new NullLifecycleStrategy(), new NullComponentMonitor())));
}
});
PicoContainer pico = buildContainer(script, null, componentFactory);
assertSame(a, pico.getComponent(A.class));
}
@Test
public void shouldReturnBaseSetupWhenProfilingIsNotAllowed() {
// Given
final CommandLineSetup baseSetup =
new CommandLineSetup(
"someTool",
Arrays.asList(
new CommandLineArgument("/arg1", CommandLineArgument.Type.PARAMETER),
new CommandLineArgument("/arg2", CommandLineArgument.Type.PARAMETER)),
Collections.singletonList(myCommandLineResource));
myCtx.checking(
new Expectations() {
{
oneOf(myAssertions).contains(RunnerAssertions.Assertion.PROFILING_IS_NOT_ALLOWED);
will(returnValue(true));
}
});
final DotTraceSetupBuilder instance = createInstance();
// When
final CommandLineSetup setup = instance.build(baseSetup).iterator().next();
// Then
myCtx.assertIsSatisfied();
then(setup).isEqualTo(baseSetup);
}
@Test(dataProvider = "runnerParamUseDotTraceCases")
public void shouldReturnBaseSetupWhenRunnerParamUseDotTraceIsEmptyOrFalse(
final String useDotTrace) {
// Given
final CommandLineSetup baseSetup =
new CommandLineSetup(
"someTool",
Arrays.asList(
new CommandLineArgument("/arg1", CommandLineArgument.Type.PARAMETER),
new CommandLineArgument("/arg2", CommandLineArgument.Type.PARAMETER)),
Collections.singletonList(myCommandLineResource));
myCtx.checking(
new Expectations() {
{
oneOf(myAssertions).contains(RunnerAssertions.Assertion.PROFILING_IS_NOT_ALLOWED);
will(returnValue(false));
oneOf(myRunnerParametersService).tryGetRunnerParameter(Constants.USE_VAR);
will(returnValue(useDotTrace));
}
});
final DotTraceSetupBuilder instance = createInstance();
// When
final CommandLineSetup setup = instance.build(baseSetup).iterator().next();
// Then
myCtx.assertIsSatisfied();
then(setup).isEqualTo(baseSetup);
}
@Test
public void should_send_mail_when_parameters_are_correct() {
final EmailBuilder email = context.mock(EmailBuilder.class);
context.checking(
new Expectations() {
{
one(email).from("*****@*****.**");
will(returnValue(email));
one(email).to("*****@*****.**");
will(returnValue(email));
one(email).withSubject("subject");
will(returnValue(email));
one(email).withBody("body");
will(returnValue(email));
one(email).withCharset("UTF-8");
will(returnValue(email));
one(email).send();
}
});
email
.from("*****@*****.**")
.to("*****@*****.**")
.withSubject("subject")
.withBody("body")
.withCharset("UTF-8")
.send();
}
@Test
public void initializationTest() throws Exception {
UrlTranslationFilter translationFilter = new UrlTranslationFilter();
final ServletContext servletContext = filterMockery.mock(ServletContext.class);
filterConfig = filterMockery.mock(FilterConfig.class);
filterMockery.checking(
new Expectations() {
{
allowing(filterConfig).getServletContext();
will(returnValue(servletContext));
allowing(filterConfig).getInitParameter(UrlTranslationFilter.ENABLED_PARAM_NAME);
will(returnValue("true"));
one(filterConfig).getInitParameter(UrlTranslationFilter.CONFIG_RESOURCE_URL_PARAM_NAME);
will(returnValue("org/xchain/framework/filter/translation-filter-test.xml"));
}
});
translationFilter.init(filterConfig);
assertTrue(translationFilter.isEnabled());
}
/**
* Tests execute with a notifier exception (for coverage).
*
* @throws Exception Shouldn't.
*/
@Test
@SuppressWarnings("unchecked")
public void testExecuteNotifierError() throws Exception {
final List<Long> recipients = Collections.singletonList(4L);
final NotificationDTO notification =
new NotificationDTO(
recipients, NotificationType.FOLLOW_PERSON, 1L, 2L, EntityType.PERSON, 3L);
context.checking(
new Expectations() {
{
oneOf(followerTranslator).translate(1, 2, 3);
will(returnValue(Collections.singletonList(notification)));
allowing(personMapper).execute(with(equal(4L)));
will(returnValue(person));
oneOf(populator).populate(with(same(notification)));
oneOf(preferencesMapper).execute(with(any(List.class)));
will(returnValue(new ArrayList<NotificationFilterPreferenceDTO>()));
oneOf(applicationNotifier).notify(with(any(NotificationDTO.class)));
will(returnValue(null));
oneOf(emailNotifier).notify(with(any(NotificationDTO.class)));
will(throwException(new Exception("BAD")));
}
});
CreateNotificationsRequest request =
new CreateNotificationsRequest(RequestType.FOLLOWER, 1, 2, 3);
sut.execute(TestContextCreator.createTaskHandlerAsyncContext(request));
context.assertIsSatisfied();
}
/** Test. */
@Test
public void testWithThemeAndGttIds() {
final Long themeId = 5L;
final Long gttId = 6L;
final MembershipCriteriaDTO mcdto = new MembershipCriteriaDTO();
mcdto.setCriteria(criteria);
mcdto.setThemeId(themeId);
mcdto.setGalleryTabTemplateId(gttId);
context.checking(
new Expectations() {
{
oneOf(ac).getParams();
will(returnValue(mcdto));
oneOf(themeProxyMapper).execute(themeId);
will(returnValue(theme));
oneOf(galleryTabTemplateProxyMappery).execute(gttId);
will(returnValue(gtt));
}
});
PersistenceRequest<MembershipCriteria> result = sut.transform(ac);
assertEquals(criteria, result.getDomainEnity().getCriteria());
assertNotNull(result.getDomainEnity().getTheme());
assertNotNull(result.getDomainEnity().getGalleryTabTemplate());
context.assertIsSatisfied();
}
@Test
public void actions_uses_action_factory_to_create_ExamineAnItem_action_for_all_visible_items() {
final Item visibleItem = mockery.mock(Item.class, "visible item");
final Item invisibleItem = mockery.mock(Item.class, "invisible item");
final ActionFactory actionFactory = mockery.mock(ActionFactory.class);
final Action examineAnItemAction = mockery.mock(Action.class);
final List<Item> visibleItems = new ArrayList<Item>();
visibleItems.add(visibleItem);
mockery.checking(
new Expectations() {
{
allowing(visibleItem).visible();
will(returnValue(true));
ignoring(visibleItem);
allowing(invisibleItem).visible();
will(returnValue(false));
ignoring(invisibleItem);
oneOf(actionFactory).createExamineAnItemAction(with(equal(visibleItems)));
will(returnValue(examineAnItemAction));
ignoring(actionFactory);
}
});
Location l = new Location("", "", null, actionFactory);
l.addItem(visibleItem);
l.addItem(invisibleItem);
List<Action> actions = l.actions();
assertTrue(actions.size() > 0);
assertThat(actions.get(0), is(examineAnItemAction));
}
@Test
public void testOneSubscriberReceivesAMessage() {
final Subscriber subscriber = context.mock(Subscriber.class);
final String message = "message";
context.checking(
new Expectations() {
{
// never(subscriber).receive(message);
oneOf(subscriber).receive(message);
// exactly(1).of(subscriber).receive(message);
// atLeast(1).of(subscriber).receive(message);
// atMost(2).of(subscriber).receive(message);
// between(1, 5).of(subscriber).receive(message);
// allowing(subscriber).receive(message);
will(returnValue("Hello world"));
}
});
Publisher publisher = new Publisher();
publisher.add(subscriber);
// execute
String answer = publisher.publish(message);
// verify
context.assertIsSatisfied();
Assert.assertEquals("Hello world", answer);
}
@Test
public void removing_all_items_from_a_location_removes_TakeAnItem_action_from_action_list() {
final Item takeableItem = mockery.mock(Item.class);
final ActionFactory actionFactory = mockery.mock(ActionFactory.class);
final Location l = new Location("", "", null, actionFactory);
mockery.checking(
new Expectations() {
{
allowing(takeableItem).visible();
will(returnValue(true));
allowing(takeableItem).takeable();
will(returnValue(true));
ignoring(takeableItem);
never(actionFactory)
.createTakeAnItemAction(
with(any(List.class)),
with(any(UserInventory.class)),
with(any(ModelLocation.class)));
ignoring(actionFactory);
}
});
l.addItem(takeableItem);
l.removeItem(takeableItem);
l.actions();
}
/** Test. Put in 3 things, get a count of 3. */
@Test
public void execute() {
final List<Long> activities = Arrays.asList(1L, 2L, 3L);
sut = new GetActivityCount(getIdsMock);
final PrincipalActionContext actionContext = context.mock(PrincipalActionContext.class);
final String request = "{}";
final Long userId = 1L;
final Principal principle = context.mock(Principal.class);
context.checking(
new Expectations() {
{
oneOf(actionContext).getParams();
will(returnValue(request));
oneOf(actionContext).getPrincipal();
will(returnValue(principle));
oneOf(principle).getId();
will(returnValue(userId));
oneOf(getIdsMock).execute(request, userId);
will(returnValue(activities));
}
});
Integer result = (Integer) sut.execute(actionContext);
Assert.assertEquals(new Integer(3), result);
context.assertIsSatisfied();
}
@Before
public void setUp() throws Exception {
MicroPlatform microPlatform = new MicroPlatform();
Mockery context = new Mockery();
Map<String, String> mimeMap = new HashMap<String, String>();
mimeMap.put("locale", "text/locale");
microPlatform.defineInstance(NameBaseMimeResolver.class, new NameBaseMimeResolver(mimeMap));
IPlatformImportMimeResolver nameBaseMimeResolver =
context.mock(IPlatformImportMimeResolver.class);
microPlatform.defineInstance(IPlatformImportMimeResolver.class, nameBaseMimeResolver);
List<String> allowedArtifacts = new ArrayList<String>();
allowedArtifacts.add("xaction");
allowedArtifacts.add("url");
LocaleImportHandler localeImportHandler = new LocaleImportHandler(allowedArtifacts);
Map<String, IPlatformImportHandler> handlers = new HashMap<String, IPlatformImportHandler>();
handlers.put("text/locale", localeImportHandler);
Map<String, String> mimes = new HashMap<String, String>();
mimes.put("locale", "text/locale");
importer = new PentahoPlatformImporter(handlers, new NameBaseMimeResolver(mimes));
importer.setRepositoryImportLogger(new Log4JRepositoryImportLogger());
}
/**
* Returns:
*
* <ul>
* <li>{@code null} if this engine is marked as closed, or if current action is not one of
* {@link HandshakeAction#NEED_TASK NEED_TASK}, {@link HandshakeAction#NEED_FAULTY_TASK
* NEED_FAULTY_TASK}.
* <li>a task mock if current action is {@link HandshakeAction#NEED_TASK NEED_TASK}. The mock
* expects to have its method {@code run()} invoked exactly once by client
* <li>a task mock whose {@code run()} method will throw an exception, if current action is
* {@link HandshakeAction#NEED_FAULTY_TASK NEED_FAULTY_TASK}. The mock expects to have its
* method {@code run()} invoked exactly once.
* </ul>
*/
@SuppressWarnings("incomplete-switch")
@Override
public synchronized Runnable getDelegatedTask() {
if (!closed && actionIndex < actions.length) {
switch (actions[actionIndex]) {
case NEED_TASK:
{
actionIndex++;
synchronized (mockery) {
final Runnable task = mockery.mock(Runnable.class, "RunnableMock" + taskCount++);
mockery.checking(
new Expectations() {
{
oneOf(task).run();
}
});
return task;
}
}
case NEED_FAULTY_TASK:
synchronized (mockery) {
final Runnable task = mockery.mock(Runnable.class, "RunnableFaultyMock" + taskCount++);
mockery.checking(
new Expectations() {
{
oneOf(task).run();
will(throwException(new RuntimeException()));
}
});
return task;
}
}
}
return null;
}
protected FundingSourceTypeService getFundingSourceTypeService() {
final FundingSourceTypeService service = context.mock(FundingSourceTypeService.class);
context.checking(
new Expectations() {
{
allowing(service).getFundingSourceType(SPONSOR_SOURCE_TYPE_ID);
will(returnValue(fundingSponsorSourceType));
allowing(service).getFundingSourceType(UNIT_SOURCE_TYPE_ID);
will(returnValue(fundingUnitSourceType));
allowing(service).getFundingSourceType(OTHER_SOURCE_TYPE_ID);
will(returnValue(fundingOtherSourceType));
allowing(service).getFundingSourceType(DEVELOPMENT_PROP_SOURCE_TYPE_ID);
will(returnValue(fundingDevProposalSourceType));
allowing(service).getFundingSourceType(INSTITUTE_PROP_SOURCE_TYPE_ID);
will(returnValue(fundingInstProposalSourceType));
allowing(service).getFundingSourceType(AWARD_SOURCE_TYPE_ID);
will(returnValue(fundingAwardSourceType));
}
});
return service;
}
@Override
public SSLSession getSession() {
synchronized (mockery) {
final SSLSession sessionMock = mockery.mock(SSLSession.class, "Session" + sessionCount++);
if (sessionCount == 1) {
mockery.checking(
new Expectations() {
{
oneOf(sessionMock).getPacketBufferSize();
will(returnValue(16916));
oneOf(sessionMock).getApplicationBufferSize();
will(returnValue(16921));
}
});
} else {
mockery.checking(
new Expectations() {
{
allowing(sessionMock).getPacketBufferSize();
will(returnValue(16916));
allowing(sessionMock).getApplicationBufferSize();
will(returnValue(16921));
}
});
}
return sessionMock;
}
}
@Test
public void deleteExpectSuccess() {
context.checking(
new Expectations() {
{
Avatar s1 = new Avatar();
s1.setId(1);
s1.setFileName(Long.toString(System.currentTimeMillis()));
Avatar s2 = new Avatar();
s2.setId(2);
s2.setFileName(Long.toString(System.currentTimeMillis()));
String applicationPath =
new File(this.getClass().getResource("").getFile()).getParent();
atLeast(1).of(config).getApplicationPath();
will(returnValue(applicationPath));
atLeast(1).of(config).getValue(ConfigKeys.AVATAR_GALLERY_DIR);
will(returnValue(""));
one(repository).get(1);
will(returnValue(s1));
one(repository).remove(s1);
one(repository).get(2);
will(returnValue(s2));
one(repository).remove(s2);
}
});
service.delete(1, 2);
context.assertIsSatisfied();
}
@Test
public void testCompareByName() throws Exception {
final Category cat1 = context.mock(Category.class, "cat1");
final Category cat2 = context.mock(Category.class, "cat2");
context.checking(
new Expectations() {
{
allowing(cat1).getRank();
will(returnValue(0));
allowing(cat1).getName();
will(returnValue("name 2"));
allowing(cat1).getCategoryId();
will(returnValue(1L));
allowing(cat2).getRank();
will(returnValue(0));
allowing(cat2).getName();
will(returnValue("name 1"));
}
});
final SortedSet<Category> set = new TreeSet<Category>(new CategoryRankNameComparator());
set.addAll(Arrays.asList(cat1, cat2));
final List<Category> list = new ArrayList<Category>(set);
assertTrue(cat2 == list.get(0));
assertTrue(cat1 == list.get(1));
}
private ProtocolSubmitAction getMockSubmitAction() {
final ProtocolSubmitAction action = context.mock(ProtocolSubmitAction.class);
context.checking(
new Expectations() {
{
allowing(action).getSubmissionTypeCode();
will(returnValue(ProtocolSubmissionType.INITIAL_SUBMISSION));
allowing(action).getProtocolReviewTypeCode();
will(returnValue(ProtocolReviewType.FULL_TYPE_CODE));
allowing(action).getSubmissionQualifierTypeCode();
will(returnValue(ProtocolSubmissionQualifierType.ANNUAL_SCHEDULED_BY_IRB));
allowing(action).getNewCommitteeId();
will(returnValue(Constants.EMPTY_STRING));
allowing(action).getNewScheduleId();
will(returnValue(Constants.EMPTY_STRING));
allowing(action).getReviewers();
will(returnValue(new ArrayList<ProtocolReviewerBean>()));
}
});
return action;
}
public abstract class AbstractControllerTest {
static {
System.setProperty(
"org.apache.commons.logging.Log", "org.apache.commons.logging.impl.Log4JLogger");
System.setProperty("log4j.configuration", "log4j.test.xml");
}
protected Mockery context = new JUnit4Mockery();
protected final HttpServletRequest mockRequest = context.mock(HttpServletRequest.class);
protected final HttpServletResponse mockResponse = context.mock(HttpServletResponse.class);
protected final Service mockService = context.mock(Service.class);
protected final Repository mockRepository = context.mock(Repository.class);
public void setUp() throws Exception {
BaseContext.pushContext();
SecurityContext securityContext = new SecurityContext(null, null);
SecurityContext.setSecurityContext(securityContext);
RequestContext requestContext =
new RequestContext(
mockRequest,
securityContext,
mockService,
null,
getRequestPath(),
null,
false,
false,
true,
mockRepository);
RequestContext.setRequestContext(requestContext);
}
protected abstract Path getRequestPath();
}