Refine search
@Test public void testPropertySetting() throws Exception { IMocksControl control = createControl(); TypeEncounter<SomeInjectableBean> encounter = control.createMock(TypeEncounter.class); Provider<Injector> injectorProvider = control.createMock(Provider.class); Injector injector = control.createMock(Injector.class); expect(encounter.getProvider(Injector.class)).andReturn(injectorProvider); expect(injectorProvider.get()).andReturn(injector).anyTimes(); Capture<MembersInjector<SomeInjectableBean>> capture = new Capture<MembersInjector<SomeInjectableBean>>(); encounter.register(and(anyObject(MembersInjector.class), capture(capture))); SecurityManager securityManager = control.createMock(SecurityManager.class); String property = "myPropertyValue"; expect(injector.getInstance(Key.get(SecurityManager.class))).andReturn(securityManager); expect(injector.getInstance(Key.get(String.class, Names.named("shiro.myProperty")))).andReturn(property); expect(injector.getInstance(Key.get(String.class, Names.named("shiro.unavailableProperty")))) .andThrow(new ConfigurationException(Collections.singleton(new Message("Not Available!")))); expect((Map)injector.getInstance(BeanTypeListener.MAP_KEY)).andReturn(Collections.EMPTY_MAP).anyTimes(); control.replay(); BeanTypeListener underTest = new BeanTypeListener(); underTest.hear(TypeLiteral.get(SomeInjectableBean.class), encounter); SomeInjectableBean bean = new SomeInjectableBean(); capture.getValue().injectMembers(bean); assertSame(securityManager, bean.securityManager); assertSame(property, bean.myProperty); assertNull(bean.unavailableProperty); control.verify(); }
ctrl = EasyMock.createStrictControl(); ctrl.checkOrder(true); backingManager = ctrl.createMock(KeyColumnValueStoreManager.class); lockerProvider = ctrl.createMock(LockerProvider.class); globalConfig = GraphDatabaseConfiguration.buildGraphConfiguration(); localConfig = GraphDatabaseConfiguration.buildGraphConfiguration(); expect(backingManager.getFeatures()).andReturn(backingFeatures).once(); inconsistentTx = ctrl.createMock(StoreTransaction.class); consistentTx = ctrl.createMock(StoreTransaction.class); expect(backingManager.beginTransaction(capture(txConfigCapture))).andReturn(inconsistentTx); expect(backingManager.beginTransaction(capture(txConfigCapture))).andReturn(consistentTx); backingLocker = ctrl.createMock(Locker.class); backingStore = ctrl.createMock(KeyColumnValueStore.class); expect(backingManager.openDatabase(STORE_NAME)).andReturn(backingStore); expect(backingStore.getName()).andReturn(STORE_NAME); ctrl.replay(); ctrl.verify(); ctrl.reset();
/** * Resets all registered mock objects (more exactly: the controls of the * mock objects) and turn them to a mock with nice behavior. For details, * see the EasyMock documentation. */ public void resetAllToNice() { for (IMocksControl c : controls) { c.resetToNice(); } }
@After public void verifyMocks() { ctrl.verify(); ctrl.reset(); // Check capture created in the @Before method assertTrue(txConfigCapture.hasCaptured()); List<BaseTransactionConfig> txCfgs = txConfigCapture.getValues(); assertEquals(2, txCfgs.size()); // First backing store transaction should use default tx config assertEquals("default", txCfgs.get(0).getCustomOption(GraphDatabaseConfiguration.UNIQUE_INSTANCE_ID)); // Second backing store transaction should use global strong consistency config assertEquals("global", txCfgs.get(1).getCustomOption(GraphDatabaseConfiguration.UNIQUE_INSTANCE_ID)); // The order in which these transactions are opened isn't really significant; // testing them in order is kind of overspecifying the impl's behavior. // Could probably relax the ordering selectively here with some thought, but // I want to keep order checking on in general for the EasyMock control. }
@Test public void testDoFilter() throws Exception { IMocksControl ctrl = createStrictControl(); FilterChain originalChain = ctrl.createMock(FilterChain.class); Filter filter1 = ctrl.createMock("filter1", Filter.class); Filter filter2 = ctrl.createMock("filter2", Filter.class); ServletRequest request = ctrl.createMock(ServletRequest.class); ServletResponse response = ctrl.createMock(ServletResponse.class); Capture<FilterChain> fc1 = new Capture<FilterChain>(); Capture<FilterChain> fc2 = new Capture<FilterChain>(); filter1.doFilter(same(request), same(response), and(anyObject(FilterChain.class), capture(fc1))); filter2.doFilter(same(request), same(response), and(anyObject(FilterChain.class), capture(fc2))); originalChain.doFilter(request, response); ctrl.replay(); SimpleFilterChain underTest = new SimpleFilterChain(originalChain, Arrays.asList(filter1, filter2).iterator()); // all we actually care about is that, if we keep calling the filter chain, everything is called in the right // order - we don't care what fc actually contains underTest.doFilter(request, response); fc1.getValue().doFilter(request, response); fc2.getValue().doFilter(request, response); ctrl.verify(); } }
private void runRequestForPath(FilterPipeline pipeline, String value, boolean matches) throws IOException, ServletException { assertEquals(0, doFilters); //create ourselves a mock request with test URI HttpServletRequest requestMock = control.createMock(HttpServletRequest.class); expect(requestMock.getRequestURI()).andReturn(value).anyTimes(); expect(requestMock.getContextPath()).andReturn("").anyTimes(); // dispatch request FilterChain filterChain = control.createMock(FilterChain.class); filterChain.doFilter(requestMock, null); control.replay(); pipeline.dispatch(requestMock, null, filterChain); control.verify(); control.reset(); if (matches) { assertEquals("filter was not run", 1, doFilters); doFilters = 0; } else { assertEquals("filter was run", 0, doFilters); } }
private static HttpServletRequest makeRequestMock(GadgetRenderingServletTest testcase) { HttpServletRequest req = testcase.control.createMock(HttpServletRequest.class); expect(req.getScheme()).andReturn("http").anyTimes(); expect(req.getServerPort()).andReturn(80).anyTimes(); expect(req.getServerName()).andReturn("example.com").anyTimes(); expect(req.getRequestURI()).andReturn("/path").anyTimes(); return req; } }
@Before public void setUp() { control = EasyMock.createControl(); request = control.createMock(JsRequest.class); jsUriManager = control.createMock(JsUriManager.class); jsUri = control.createMock(JsUri.class); uri = Uri.parse("http://example.org/foo.xml"); response = new JsResponseBuilder(); processor = new JsLoadProcessor(jsUriManager, 1234, true); EasyMock.expect(request.getJsUri()).andReturn(jsUri); }
@Before public void setUp() throws GadgetException { control = EasyMock.createControl(); request = control.createMock(JsRequest.class); response = new JsResponseBuilder(); processor = new AddJslLoadedVariableProcessor(fregProvider); EasyMock.reset(fregProvider, freg); EasyMock.expect(fregProvider.get(EasyMock.anyObject(String.class))).andReturn(freg).anyTimes(); Set<String> required = Sets.newHashSet(REQ_LIBS); EasyMock.expect(freg.getAllFeatureNames()).andReturn(required).anyTimes(); EasyMock.replay(fregProvider, freg); }
@Test public void testMutateManyWithLockUsesConsistentTx() throws BackendException { final ImmutableList<Entry> adds = ImmutableList.of(StaticArrayEntry.of(DATA_COL, DATA_VAL)); final ImmutableList<StaticBuffer> dels = ImmutableList.<StaticBuffer>of(); Map<String, Map<StaticBuffer, KCVMutation>> mutations = ImmutableMap.<String, Map<StaticBuffer, KCVMutation>>of(STORE_NAME, ImmutableMap.<StaticBuffer, KCVMutation>of(DATA_KEY, new KCVMutation(adds, dels))); final KeyColumn kc = new KeyColumn(LOCK_KEY, LOCK_COL); // Acquire a lock backingLocker.writeLock(kc, consistentTx); // 2. Run mutateMany // 2.1. Check locks & expected values before mutating data backingLocker.checkLocks(consistentTx); StaticBuffer nextBuf = BufferUtil.nextBiggerBuffer(kc.getColumn()); KeySliceQuery expectedValueQuery = new KeySliceQuery(kc.getKey(), kc.getColumn(), nextBuf); expect(backingStore.getSlice(expectedValueQuery, consistentTx)) // expected value read must use strong consistency .andReturn(StaticArrayEntryList.of(StaticArrayEntry.of(LOCK_COL, LOCK_VAL))); // 2.2. Run mutateMany on backing manager to modify data backingManager.mutateMany(mutations, consistentTx); // writes by txs with locks must use strong consistency ctrl.replay(); // Lock acquisition expectStore.acquireLock(LOCK_KEY, LOCK_COL, LOCK_VAL, expectTx); // Mutate expectManager.mutateMany(mutations, expectTx); }
IMocksControl ctrl = createStrictControl(); Injector injector = ctrl.createMock(Injector.class); Map<String, Key<? extends Filter>[]> chainMap = new LinkedHashMap<String, Key<? extends Filter>[]>(); chainMap.put(chainThree, new Key[]{key3a, key3b}); PatternMatcher patternMatcher = ctrl.createMock(PatternMatcher.class); ServletRequest request = ctrl.createMock(HttpServletRequest.class); ServletResponse response = ctrl.createMock(HttpServletResponse.class); FilterChain originalChain = ctrl.createMock(FilterChain.class); expect(request.getCharacterEncoding()).andStubReturn(null); Filter filter2a = ctrl.createMock(Filter.class); Filter filter2b = ctrl.createMock(Filter.class); expect((Filter)injector.getInstance(key2a)).andReturn(filter2a); ctrl.replay(); ctrl.verify(); ctrl.reset(); ctrl.replay(); ctrl.verify();
@Test public void testRemove() throws Exception { ListenerCollection<Runnable> collection = new ListenerCollection<>(); IMocksControl control = EasyMock.createControl(); Runnable l1 = control.createMock("l1", Runnable.class); Runnable l2 = control.createMock("l2", Runnable.class); control.checkOrder(true); l2.run(); EasyMock.expectLastCall().once(); control.replay(); collection.add(l1); collection.add(l2); collection.remove(l1); collection.safeForEach(Runnable::run); control.verify(); }
/** * Creates a mock object that implements the given interface. * * @param <T> * the interface or class that the mock object should * implement/extend. * @param <R> * the returned type. In general T == R but when mocking a generic type, it won't so to be nice with the * caller, we return a different type * @param toMock * the interface or class that the mock object should * implement/extend. * @return the mock object. * @since 4.0 */ default <T, R> R mock(Class<T> toMock) { return createMock(toMock); }
/** * Switches all registered mock objects (more exactly: the controls of the * mock objects) to replay mode. For details, see the EasyMock * documentation. */ public void replayAll() { for (IMocksControl c : controls) { c.replay(); } }
/** * Resets all registered mock objects (more exactly: the controls of the * mock objects). For details, see the EasyMock documentation. */ public void resetAll() { for (IMocksControl c : controls) { c.reset(); } }
/** * Verifies all registered mock objects have their expectations met and that no * unexpected call was performed. * <p> * This method as same effect as calling {@link #verifyAllRecordings()} * followed by {@link #verifyAllUnexpectedCalls()}. */ public void verifyAll() { for (IMocksControl c : controls) { c.verify(); } }
@Override public void checkOrder(final boolean state) { delegate.checkOrder(state); }
public void testSimple() throws Exception { IMocksControl testControl = createControl(); TestFilterChain testFilterChain = new TestFilterChain(); HttpServletRequest req = testControl.createMock(HttpServletRequest.class); HttpServletResponse res = testControl.createMock(HttpServletResponse.class); expect(req.getMethod()).andReturn("GET").anyTimes(); expect(req.getRequestURI()).andReturn("/bar/foo").anyTimes(); expect(req.getServletPath()).andReturn("/bar/foo").anyTimes(); expect(req.getContextPath()).andReturn("").anyTimes(); testControl.replay(); guiceFilter.doFilter(req, res, testFilterChain); assertFalse(testFilterChain.isTriggered()); assertFalse(fooServlet.isTriggered()); assertTrue(barServlet.isTriggered()); testControl.verify(); }
private JsRequest mockJsRequest(JsUri uri) { JsRequest request = control.createMock(JsRequest.class); expect(request.getJsUri()).andReturn(uri).anyTimes(); return request; } }