private BusinessObjectService getMockBusinessObjectService() { final BusinessObjectService service = context.mock(BusinessObjectService.class); context.checking( new Expectations() { { Map<String, Object> fieldValues1 = new HashMap<String, Object>(); fieldValues1.put(REL_TYPE_SORT_ID_FIELD_NAME, SORT_ID_1); // fieldValues1.put(GROUP_NAME_FIELD_NAME, GROUP_NAME); FinIntEntityRelType finIntEntityRelType = new FinIntEntityRelType(); finIntEntityRelType.setRelationshipTypeCode(CODE_1); allowing(service).findMatching(FinIntEntityRelType.class, fieldValues1); will(returnValue(Collections.singleton(finIntEntityRelType))); } }); context.checking( new Expectations() { { Map<String, String> fieldValues = new HashMap<String, String>(); fieldValues.put(DESCRIPTION_FIELD_NAME, DESCRIPTION_1); FinIntEntityRelType finIntEntityRelType = new FinIntEntityRelType(); finIntEntityRelType.setRelationshipTypeCode(CODE_1); allowing(service).findMatching(FinIntEntityRelType.class, fieldValues); will(returnValue(Collections.singleton(finIntEntityRelType))); } }); return service; }
public void testDoesNotAssignPassiveLeafIfDisabled() throws Exception { ConnectionSettings.EVER_ACCEPTED_INCOMING.setValue(true); DHTSettings.ENABLE_PASSIVE_LEAF_DHT_MODE.setValue(false); long startTime = System.currentTimeMillis() - DHTSettings.MIN_PASSIVE_LEAF_DHT_INITIAL_UPTIME.getValue(); PrivilegedAccessor.setValue(nodeAssigner, "startTime", new Long(startTime)); mockery.checking(buildBandwdithExpectations(true)); mockery.checking( buildDHTExpectations( DHTMode.INACTIVE, true, true, false, // can't receive unsolicited DHTSettings.MIN_PASSIVE_LEAF_DHT_AVERAGE_UPTIME.getValue() + 1, false, false)); mockery.checking( new Expectations() { { never(dhtManager).start(with(Matchers.any(DHTMode.class))); } }); assignerRunnable.run(); mockery.assertIsSatisfied(); }
public void testPassiveLeafDoesNotNeedHardCore() throws Exception { // not accepted incoming previously therefore not hardcore long startTime = System.currentTimeMillis() - DHTSettings.MIN_PASSIVE_LEAF_DHT_INITIAL_UPTIME.getValue(); PrivilegedAccessor.setValue(nodeAssigner, "startTime", new Long(startTime)); mockery.checking(buildBandwdithExpectations(true)); mockery.checking( buildDHTExpectations( DHTMode.INACTIVE, true, true, false, // can't receive unsolicited DHTSettings.MIN_PASSIVE_LEAF_DHT_AVERAGE_UPTIME.getValue() + 1, false, false)); mockery.checking( new Expectations() { { one(dhtManager).start(DHTMode.PASSIVE_LEAF); } }); assignerRunnable.run(); mockery.assertIsSatisfied(); }
public void testStopsDHTWhenDisabled() throws Exception { ConnectionSettings.EVER_ACCEPTED_INCOMING.setValue(true); long startTime = System.currentTimeMillis() - DHTSettings.MIN_ACTIVE_DHT_INITIAL_UPTIME.getValue(); PrivilegedAccessor.setValue(nodeAssigner, "startTime", new Long(startTime)); mockery.checking(buildBandwdithExpectations(true)); mockery.checking( buildDHTExpectations( DHTMode.ACTIVE, false, true, true, DHTSettings.MIN_ACTIVE_DHT_AVERAGE_UPTIME.getValue() + 1, false, false)); mockery.checking( new Expectations() { { one(dhtManager).stop(); } }); assignerRunnable.run(); mockery.assertIsSatisfied(); }
public void testDoesNotAssignLowInitialUptime() throws Exception { ConnectionSettings.EVER_ACCEPTED_INCOMING.setValue(true); // no initial uptime mockery.checking(buildBandwdithExpectations(true)); mockery.checking( buildDHTExpectations( DHTMode.INACTIVE, true, true, true, DHTSettings.MIN_ACTIVE_DHT_AVERAGE_UPTIME.getValue() + 1, false, false)); mockery.checking( new Expectations() { { never(dhtManager).start(with(Matchers.any(DHTMode.class))); } }); assignerRunnable.run(); mockery.assertIsSatisfied(); }
public void testDoesNotAssignLowAverageUptime() throws Exception { ConnectionSettings.EVER_ACCEPTED_INCOMING.setValue(true); long startTime = System.currentTimeMillis() - DHTSettings.MIN_ACTIVE_DHT_INITIAL_UPTIME.getValue(); PrivilegedAccessor.setValue(nodeAssigner, "startTime", new Long(startTime)); mockery.checking(buildBandwdithExpectations(true)); mockery.checking( buildDHTExpectations( DHTMode.INACTIVE, true, true, true, 0, // no average uptime false, false)); mockery.checking( new Expectations() { { never(dhtManager).start(with(Matchers.any(DHTMode.class))); } }); assignerRunnable.run(); mockery.assertIsSatisfied(); }
/** * 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; }
@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; } }
@Before protected void setUp() throws Exception { Mockery contractServiceMockery = new Mockery(); final IContractService contractService = contractServiceMockery.mock(IContractService.class); contractServiceMockery.checking( new Expectations() { { allowing(contractService).searchOperaLogByWorkflowId("1"); List<ContractOperatorLog> contractLogList = new ArrayList<ContractOperatorLog>(); ContractOperatorLog c = new ContractOperatorLog(); c.setCreateUser("1"); contractLogList.add(c); will(returnValue(contractLogList)); } }); contractWorkflowManager.setContractService(contractService); Mockery contractWorkflowServiceMockery = new Mockery(); final IContractWorkflowService contractWorkflowService = contractWorkflowServiceMockery.mock(IContractWorkflowService.class); contractWorkflowServiceMockery.checking( new Expectations() { { allowing(contractWorkflowService) .queryContractWorkflowInfoByBusino(with(any(String.class))); will(returnValue(new ContractWorkflowInfo())); } }); contractWorkflowManager.setContractWorkflowService(contractWorkflowService); Mockery employeeServiceMockery = new Mockery(); final IEmployeeService employeeService = employeeServiceMockery.mock(IEmployeeService.class); employeeServiceMockery.checking( new Expectations() { { allowing(employeeService).getEmpById("1"); Employee employee = new Employee(); employee.setEmpCode("1"); will(returnValue(employee)); } }); contractWorkflowManager.setEmployeeService(employeeService); Mockery userServiceMockery = new Mockery(); final IUserService userService = userServiceMockery.mock(IUserService.class); userServiceMockery.checking( new Expectations() { { allowing(userService).findByLoginName("1"); User user = new User(); user.setId("1"); will(returnValue(user)); allowing(userService).getUserRoleFunDeptById("1"); will(returnValue(user)); } }); contractWorkflowManager.setUserService(userService); }
public void testDoesNotPromoteIfNoUDP() throws Exception { ConnectionSettings.EVER_ACCEPTED_INCOMING.setValue(true); ApplicationSettings.AVERAGE_UPTIME.setValue(UltrapeerSettings.MIN_AVG_UPTIME.getValue() + 1); assertFalse(UltrapeerSettings.EVER_ULTRAPEER_CAPABLE.getValue()); mockery.checking(buildBandwdithExpectations(true)); // no UDP support mockery.checking(buildUltrapeerExpectations(false, true, 0l, false, DHTMode.INACTIVE, false)); // will not get promoted mockery.checking(buildPromotionExpectations(false)); assignerRunnable.run(); assertFalse(UltrapeerSettings.EVER_ULTRAPEER_CAPABLE.getValue()); mockery.assertIsSatisfied(); }
public void testDoesNotPromoteModemSpeed() throws Exception { ConnectionSettings.EVER_ACCEPTED_INCOMING.setValue(true); ApplicationSettings.AVERAGE_UPTIME.setValue(UltrapeerSettings.MIN_AVG_UPTIME.getValue() + 1); assertFalse(UltrapeerSettings.EVER_ULTRAPEER_CAPABLE.getValue()); // everything else fine // setting up bad bandwidth to simulate a modem speed mockery.checking(buildBandwdithExpectations(false)); mockery.checking(buildUltrapeerExpectations(true, true, 0l, false, DHTMode.INACTIVE, false)); mockery.checking(buildPromotionExpectations(false)); assignerRunnable.run(); assertFalse(UltrapeerSettings.EVER_ULTRAPEER_CAPABLE.getValue()); mockery.assertIsSatisfied(); }
public void testPromotesUltrapeer() throws Exception { ConnectionSettings.EVER_ACCEPTED_INCOMING.setValue(true); ApplicationSettings.AVERAGE_UPTIME.setValue(UltrapeerSettings.MIN_AVG_UPTIME.getValue() + 1); assertFalse(UltrapeerSettings.EVER_ULTRAPEER_CAPABLE.getValue()); // set up some conditions for ultrapeer-ness // all of them are required mockery.checking(buildBandwdithExpectations(true)); mockery.checking(buildUltrapeerExpectations(true, true, 0l, false, DHTMode.INACTIVE, true)); mockery.checking(buildPromotionExpectations(true)); assignerRunnable.run(); assertTrue(UltrapeerSettings.EVER_ULTRAPEER_CAPABLE.getValue()); mockery.assertIsSatisfied(); }
public static AttributeInterface createAttribute( final String name, final EntityInterface entity, final TermType termType) { final AttributeTypeInformationInterface attrInfo; switch (termType) { case Numeric: attrInfo = context.mock(NumericTypeInformationInterface.class, getI()); break; case Date: attrInfo = context.mock(DateTypeInformationInterface.class, getI()); context.checking( new Expectations() { { allowing((DateTypeInformationInterface) attrInfo).getFormat(); will(returnValue("foo")); } }); break; case Timestamp: attrInfo = context.mock(DateTypeInformationInterface.class, getI()); context.checking( new Expectations() { { allowing((DateTypeInformationInterface) attrInfo).getFormat(); will(returnValue("MM-dd-yyyy HH:mm")); } }); break; case String: attrInfo = context.mock(StringTypeInformationInterface.class, getI()); break; default: throw new IllegalArgumentException(); } final AttributeInterface attribute = context.mock(AttributeInterface.class, getI()); context.checking( new Expectations() { { allowing(attribute).getName(); will(returnValue(name)); allowing(attribute).getEntity(); will(returnValue(entity)); allowing(attribute).getAttributeTypeInformation(); will(returnValue(attrInfo)); } }); return attribute; }
@Test public void shouldLogMessageIndicatingFailedHeaderMatch() { context.checking( new Expectations() { { one(notifier) .info( "URL /for/logging is match, but header Content-Type is not. For a match, value should equal text/xml"); } }); RequestPattern requestPattern = new RequestPattern(POST, "/for/logging"); ValuePattern headerPattern = new ValuePattern(); headerPattern.setEqualTo("text/xml"); requestPattern.addHeader("Content-Type", headerPattern); Request request = aRequest(context) .withUrl("/for/logging") .withMethod(POST) .withHeader("Content-Type", "text/plain") .build(); requestPattern.isMatchedBy(request); }
@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(); }
@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; }
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; }
@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 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(); }
@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); }
/** * 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 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 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 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)); }
/** 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 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 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()); }
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; }
/** 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(); }