public void testPact(@Observes EventContext<Test> testEventContext) throws Throwable { final Test event = testEventContext.getEvent(); final TestClass testClass = event.getTestClass(); final PactVerification pactVerification = event.getTestMethod().getAnnotation(PactVerification.class); if (pactVerification == null) { logger.log(Level.INFO, String.format("Method %s is not annotated with %s annotation and it is going to be executed as normal junit test.", event.getTestMethod().getName(), PactVerification.class.getName())); testEventContext.proceed(); return; } executeConsumerTest(testEventContext, testClass, pactVerification); }
public void testPact(@Observes EventContext<Test> testEventContext) throws Throwable { final Test event = testEventContext.getEvent(); final TestClass testClass = event.getTestClass(); final PactVerification pactVerification = event.getTestMethod().getAnnotation(PactVerification.class); if (pactVerification == null) { logger.log(Level.INFO, String.format( "Method %s is not annotated with %s annotation and it is going to be executed as normal junit test.", event.getTestMethod().getName(), PactVerification.class.getName())); testEventContext.proceed(); return; } executeConsumerTest(testEventContext, testClass, pactVerification); } }
public void executePacts(@Observes EventContext<Test> test) { TestClass testClass = test.getEvent().getTestClass(); final List<Throwable> errors = new ArrayList<>(); validateState(testClass, errors); validateTargetRequestFilters(testClass, errors); validateTestTarget(testClass, errors); Field interactionField = validateAndGetResourceField(testClass, RequestResponseInteraction.class, CurrentInteraction.class, errors); Field consumerField = validateAndGetResourceField(testClass, Consumer.class, CurrentConsumer.class, errors); if (errors.size() != 0) { String errorMessage = errors.stream() .map(error -> error.getMessage()) .collect(Collectors.joining(" * ")); throw new IllegalArgumentException(errorMessage); } Pacts pacts = pactsInstance.get(); if (pacts != null) { executePacts(test, pacts, interactionField, consumerField); } else { logger.log(Level.WARNING, "No pacts read for execution"); } }
public void executePacts(@Observes EventContext<Test> test) { TestClass testClass = test.getEvent().getTestClass(); final List<Throwable> errors = new ArrayList<>(); validateState(testClass, errors); validateTargetRequestFilters(testClass, errors); validateTestTarget(testClass, errors); Field interactionField = validateAndGetResourceField(testClass, RequestResponseInteraction.class, CurrentInteraction.class, errors); Field consumerField = validateAndGetResourceField(testClass, Consumer.class, CurrentConsumer.class, errors); if (errors.size() != 0) { String errorMessage = errors.stream() .map(error -> error.getMessage()) .collect(Collectors.joining(" * ")); throw new IllegalArgumentException(errorMessage); } Pacts pacts = pactsInstance.get(); if (pacts != null) { executePacts(test, pacts, interactionField, consumerField); } else { logger.log(Level.WARNING, "No pacts read for execution"); } }
public void execute(@Observes EventContext<Test> context) { Test event = context.getEvent(); Method testMethod = event.getTestMethod(); WithinNamespace ns = testMethod.getAnnotation(WithinNamespace.class); if (ns == null) { ns = event.getTestClass().getAnnotation(WithinNamespace.class); if (ns == null) { Class<?> testClass = event.getTestClass().getJavaClass(); ns = testClass.getPackage().getAnnotation(WithinNamespace.class); } } if (ns != null) { runWithinNamespaces(context, ns.value()); } else { context.proceed(); } }
public void testPact(@Observes(precedence = -50) EventContext<Test> testEventContext, Deployment deployment) throws Throwable { final Test event = testEventContext.getEvent(); final TestClass testClass = event.getTestClass(); // We need to check this because in case of embedded containers this class is executed too if (RunModeUtils.isRunAsClient(deployment, testClass.getJavaClass(), event.getTestMethod())) { final PactVerification pactVerification = event.getTestMethod().getAnnotation(PactVerification.class); if (pactVerification == null) { logger.log(Level.INFO, String.format("Method %s is not annotated with %s annotation and it is going to be executed as normal junit test.", event.getTestMethod().getName(), PactVerification.class.getName())); testEventContext.proceed(); return; } executeConsumerTest(testEventContext, testClass, pactVerification); } else { // We are in container and this class is executed in client side so we should only pass the execution and incontainer class will do the job testEventContext.proceed(); } }
public void testPact(@Observes(precedence = -50) EventContext<Test> testEventContext, Deployment deployment) throws Throwable { final Test event = testEventContext.getEvent(); final TestClass testClass = event.getTestClass(); // We need to check this because in case of embedded containers this class is executed too if (RunModeUtils.isRunAsClient(deployment, testClass, event.getTestMethod())) { final PactVerification pactVerification = event.getTestMethod().getAnnotation(PactVerification.class); if (pactVerification == null) { logger.log(Level.INFO, String.format( "Method %s is not annotated with %s annotation and it is going to be executed as normal junit test.", event.getTestMethod().getName(), PactVerification.class.getName())); testEventContext.proceed(); return; } executeConsumerTest(testEventContext, testClass, pactVerification); } else { // We are in container and this class is executed in client side so we should only pass the execution and incontainer class will do the job testEventContext.proceed(); } } }
public void testPact(@Observes(precedence = -50) EventContext<Test> testEventContext) throws Throwable { final Test event = testEventContext.getEvent(); final TestClass testClass = event.getTestClass(); final PactVerification pactVerification = event.getTestMethod().getAnnotation(PactVerification.class); if (pactVerification == null) { logger.log(Level.INFO, String.format("Method %s is not annotated with %s annotation and it is going to be executed as normal junit test.", event.getTestMethod().getName(), PactVerification.class.getName())); testEventContext.proceed(); return; } final ConsumerProviderPair consumerProviderPair = executeConsumerTest(testEventContext, testClass, pactVerification); // Send results back to client final String filename = getFilename(consumerProviderPair); final byte[] content = loadPact(filename); getCommandService().execute(new PactFilesCommand(filename, content)); }
public void testPact(@Observes(precedence = -50) EventContext<Test> testEventContext) throws Throwable { final Test event = testEventContext.getEvent(); final TestClass testClass = event.getTestClass(); final PactVerification pactVerification = event.getTestMethod().getAnnotation(PactVerification.class); if (pactVerification == null) { logger.log(Level.INFO, String.format( "Method %s is not annotated with %s annotation and it is going to be executed as normal junit test.", event.getTestMethod().getName(), PactVerification.class.getName())); testEventContext.proceed(); return; } final ConsumerProviderPair consumerProviderPair = executeConsumerTest(testEventContext, testClass, pactVerification); // Send results back to client final String filename = getFilename(consumerProviderPair); final byte[] content = loadPact(filename); getCommandService().execute(new PactFilesCommand(filename, content)); }
private ConsumerProviderPair executePactFragment(EventContext<Test> testEventContext, String currentProvider, PactVerification pactVerification) throws Throwable { final Object testInstance = testEventContext.getEvent().getTestInstance(); final TestClass testClass = testEventContext.getEvent().getTestClass(); Optional<PactMethod> possiblePactMethod = findPactMethod(currentProvider, testClass, pactVerification); if (!possiblePactMethod.isPresent()) { throw new UnsupportedOperationException("Could not find method with @Pact for the provider " + currentProvider); } PactMethod pactMethod = possiblePactMethod.get(); Pact pact = pactMethod.getPact(); PactDslWithProvider dslBuilder = ConsumerPactBuilder.consumer(pact.consumer()).hasPactWith(currentProvider); PactFragment pactFragment; try { pactFragment = (PactFragment) pactMethod.getMethod().invoke(testInstance, dslBuilder); } catch (Exception e) { throw new RuntimeException("Failed to invoke pact method", e); } VerificationResult result = runPactTest(testEventContext, pactFragment); validateResult(result, pactVerification); return new ConsumerProviderPair(pact.consumer(), currentProvider); }
private ConsumerProviderPair executePactFragment(EventContext<Test> testEventContext, String currentProvider, PactVerification pactVerification) throws Throwable { final Object testInstance = testEventContext.getEvent().getTestInstance(); final TestClass testClass = testEventContext.getEvent().getTestClass(); Optional<PactMethod> possiblePactMethod = findPactMethod(currentProvider, testClass, pactVerification); if (!possiblePactMethod.isPresent()) { throw new UnsupportedOperationException( "Could not find method with @Pact for the provider " + currentProvider); } PactMethod pactMethod = possiblePactMethod.get(); Pact pact = pactMethod.getPact(); PactDslWithProvider dslBuilder = ConsumerPactBuilder.consumer(pact.consumer()).hasPactWith(currentProvider); PactFragment pactFragment; try { pactFragment = (PactFragment) pactMethod.getMethod().invoke(testInstance, dslBuilder); } catch (Exception e) { throw new RuntimeException("Failed to invoke pact method", e); } VerificationResult result = runPactTest(testEventContext, pactFragment); validateResult(result, pactVerification); return new ConsumerProviderPair(pact.consumer(), currentProvider); }
public void execute(@Observes Test event) throws Exception { boolean runAsClient = RunModeUtils.isRunAsClientAndCheck( this.deployment.get(), event.getTestClass(), event.getTestMethod()); if (runAsClient) { executionEvent.fire(new LocalExecutionEvent(event.getTestMethodExecutor())); } else { executionEvent.fire(new RemoteExecutionEvent(event.getTestMethodExecutor())); } } }
public void execute(@Observes Test event) throws Exception { boolean runAsClient = RunModeUtils.isRunAsClientAndCheck( this.deployment.get(), event.getTestClass(), event.getTestMethod()); if (runAsClient) { executionEvent.fire(new LocalExecutionEvent(event.getTestMethodExecutor())); } else { executionEvent.fire(new RemoteExecutionEvent(event.getTestMethodExecutor())); } } }
public void register_interceptor(@Observes EventContext<Test> ctx) { invoked = false; try { Test event = ctx.getEvent(); if (event.getTestClass().getJavaClass() == TestInterceptorRegistration.class) { WebDriver browser = org.jboss.arquillian.graphene.context.GrapheneContext.getContextFor(Default.class).getWebDriver(); ((GrapheneProxyInstance) browser).registerInterceptor(new Interceptor() { @Override public Object intercept(InvocationContext context) throws Throwable { invoked = true; return context.invoke(); } @Override public int getPrecedence() { return 0; } }); } } finally { ctx.proceed(); } } }
private void executePacts(EventContext<Test> test, final Pacts pacts, final Field interactionField, final Field consumerField) { final TestClass testClass = test.getEvent().getTestClass(); final Object testInstance = test.getEvent().getTestInstance(); for (Pact pact : pacts.getPacts()) { RequestResponsePact requestResponsePact = (RequestResponsePact) pact; // Inject current consumer if (consumerField != null) { setField(testInstance, consumerField, pact.getConsumer()); } for (final RequestResponseInteraction interaction : requestResponsePact.getInteractions()) { executeStateChanges(interaction, testClass, testInstance); Target target = targetInstance.get(); if (target instanceof ArquillianTestClassAwareTarget) { ArquillianTestClassAwareTarget arquillianTestClassAwareTarget = (ArquillianTestClassAwareTarget) target; arquillianTestClassAwareTarget.setTestClass(testClass, testInstance); } if (target instanceof PactProviderExecutionAwareTarget) { PactProviderExecutionAwareTarget pactProviderExecutionAwareTarget = (PactProviderExecutionAwareTarget) target; pactProviderExecutionAwareTarget.setConsumer(pact.getConsumer()); pactProviderExecutionAwareTarget.setRequestResponseInteraction(interaction); } // Inject current interaction to test if (interactionField != null) { setField(testInstance, interactionField, interaction); } // run the test test.proceed(); } } }
private void executePacts(EventContext<Test> test, final Pacts pacts, final Field interactionField, final Field consumerField) { final TestClass testClass = test.getEvent().getTestClass(); final Object testInstance = test.getEvent().getTestInstance();