/** Verify .cmp/.app and .css files are created through QuickFix screen. */ public void testCreationQuickFix() throws Exception { String namespace = "auratest"; String cmpName = String.format("nonExistent%s%s", defType.name(), System.currentTimeMillis()); DefDescriptor<?> defDescriptor = createComponentDefDescriptor(namespace, cmpName); DefDescriptor<?> defDescriptorCss = Aura.getDefinitionService().getDefDescriptor(namespace + "." + cmpName, StyleDef.class); BaseComponentQuickFixWidget quickFixUIWidget; quickFixUIWidget = new BaseComponentQuickFixWidget(defType, this); try { open(String.format("/%s/%s%s", namespace, cmpName, typeSuffix), Mode.DEV); quickFixUIWidget.verifyToolbarAndClickCreate(defDescriptor.getQualifiedName()); quickFixUIWidget.verifyCustomizationMenu(); quickFixUIWidget.selectCssCheckbox(true); quickFixUIWidget.clickFix(true, String.format("TODO: %s:%s", namespace, cmpName)); // // Serverside verification // This needs to be very careful, as static registries can stay constant. // getAuraTestingUtil().restartContext(); assertTrue("Failed to locate the definition", defDescriptor.exists()); assertTrue("Failed to locate the css definition", defDescriptorCss.exists()); } finally { quickFixUIWidget.deleteFiles(defDescriptor); } }
public DefOverviewModel() throws QuickFixException { AuraContext context = Aura.getContextService().getCurrentContext(); BaseComponent<?, ?> component = context.getCurrentComponent(); String desc = (String) component.getAttributes().getValue("descriptor"); DefType defType = DefType.valueOf(((String) component.getAttributes().getValue("defType")).toUpperCase()); DefinitionService definitionService = Aura.getDefinitionService(); DefDescriptor<?> descriptor = definitionService.getDefDescriptor(desc, defType.getPrimaryInterface()); Definition def = descriptor.getDef(); ReferenceTreeModel.assertAccess(def); Map<DefType, List<DefModel>> depsMap = Maps.newEnumMap(DefType.class); Set<DefDescriptor<?>> deps = Sets.newHashSet(); def.appendDependencies(deps); for (DefDescriptor<?> dep : deps) { DefType type = dep.getDefType(); List<DefModel> depsList = depsMap.get(type); if (depsList == null) { depsList = Lists.newArrayList(); depsMap.put(type, depsList); } depsList.add(new DefModel(dep)); } for (Entry<DefType, List<DefModel>> entry : depsMap.entrySet()) { List<DefModel> list = entry.getValue(); Collections.sort(list); Map<String, Object> group = Maps.newHashMap(); group.put("type", AuraTextUtil.initCap(entry.getKey().toString().toLowerCase())); group.put("list", list); dependencies.add(group); } }
private String createURI( String namespace, String name, DefType defType, Mode mode, String access, String qs) { if (mode == null) { try { mode = Aura.getContextService().getCurrentContext().getMode(); } catch (Throwable t) { mode = Mode.AUTOJSTEST; // TODO: default to PROD } } String ret = String.format(GET_URI, namespace, name, defType.name(), mode.toString(), access); if (qs != null) { ret = String.format("%s&%s", ret, qs); } return ret; }
/** * Verify error message that is displayed when attempting to create a cmp bundle with a * non-existing namespace. */ public void testCreationQuickFixNonexistentNamespace() throws Exception { String namespace = String.format("nonExistentNamespace%s", System.currentTimeMillis()); String cmpName = String.format("nonExistent%s%s", defType.name(), System.currentTimeMillis()); DefDescriptor<?> defDescriptor = createComponentDefDescriptor(namespace, cmpName); BaseComponentQuickFixWidget quickFixUIWidget; quickFixUIWidget = new BaseComponentQuickFixWidget(defType, this); try { open(String.format("/%s/%s%s", namespace, cmpName, typeSuffix), Mode.DEV); quickFixUIWidget.verifyToolbarAndClickCreate(defDescriptor.getQualifiedName()); quickFixUIWidget.verifyCustomizationMenu(); quickFixUIWidget.clickFix(false, "Cannot find location to save definition"); assertFalse("Should not have created component bundle", defDescriptor.exists()); } finally { quickFixUIWidget.deleteFiles(defDescriptor); } }
/** * Verify that multiple component bundles can be created by entering the DefDescriptors in, comma * separated. */ public void testMultipleDescriptors() throws Exception { String namespace = String.format("auratest", System.currentTimeMillis()); String cmpName1 = String.format("nonExistent1%s%s", defType.name(), System.currentTimeMillis()); String cmpName2 = String.format("nonExistent2%s%s", defType.name(), System.currentTimeMillis()); DefDescriptor<?> defDescriptor1 = createComponentDefDescriptor(namespace, cmpName1); DefDescriptor<?> defDescriptor2 = createComponentDefDescriptor(namespace, cmpName2); BaseComponentQuickFixWidget quickFixUIWidget; quickFixUIWidget = new BaseComponentQuickFixWidget(defType, this); try { open(String.format("/%s/%s%s", namespace, cmpName1, typeSuffix), Mode.DEV); quickFixUIWidget.verifyToolbarAndClickCreate(defDescriptor1.getQualifiedName()); quickFixUIWidget.verifyCustomizationMenu(); quickFixUIWidget.setDescriptorNames( namespace + ":" + cmpName1 + ", " + namespace + ":" + cmpName2); quickFixUIWidget.clickFix(true, String.format("TODO: %s:%s", namespace, cmpName1)); assertTrue("Should not have created component bundle", defDescriptor1.exists()); assertTrue("Should not have created component bundle", defDescriptor2.exists()); } finally { quickFixUIWidget.deleteFiles(defDescriptor1); quickFixUIWidget.deleteFiles(defDescriptor2); } }
@Override public void doFilter(ServletRequest req, ServletResponse res, FilterChain chain) throws ServletException, IOException { if (!Aura.getConfigAdapter().isTestAllowed()) { chain.doFilter(req, res); return; } TestContextAdapter testContextAdapter = Aura.get(TestContextAdapter.class); if (testContextAdapter == null) { chain.doFilter(req, res); return; } // Check for requests to execute a JSTest, i.e. initial component GETs with particular // parameters. HttpServletRequest request = (HttpServletRequest) req; if ("GET".equals(request.getMethod())) { String contextPath = request.getContextPath(); String uri = request.getRequestURI(); String browserType = request.getParameter("aura.browserType"); if (browserType == null) { // read it from request header String ua = request.getHeader(HttpHeaders.USER_AGENT); if (ua != null) { ua = ua.toLowerCase(); if (ua.contains("chrome")) { browserType = "GOOGLECHROME"; } else if (ua.contains("safari")) { browserType = "SAFARI"; } else if (ua.contains("firefox")) { browserType = "FIREFOX"; } else if (ua.contains("ipad")) { browserType = "IPAD"; } else if (ua.contains("iphone")) { browserType = "IPHONE"; } else if (ua.contains("msie 10")) { browserType = "IE10"; } else if (ua.contains("msie 9")) { browserType = "IE9"; } else if (ua.contains("msie 8")) { browserType = "IE8"; } else if (ua.contains("msie 7")) { browserType = "IE7"; } else if (ua.contains("msie 6")) { browserType = "IE6"; } else if (ua.contains("trident/7.0")) { browserType = "IE11"; } else if (ua.contains("edge/12")) { browserType = "IE12"; } else { browserType = "OTHER"; } } } String path; if (uri.startsWith(contextPath)) { path = uri.substring(contextPath.length()); } else { path = uri; } Matcher matcher = AuraRewriteFilter.DESCRIPTOR_PATTERN.matcher(path); if (matcher.matches()) { // Extract the target component since AuraContext usually does not have the app descriptor // set yet. DefType type = "app".equals(matcher.group(3)) ? DefType.APPLICATION : DefType.COMPONENT; String namespace = matcher.group(1); String name = matcher.group(2); DefDescriptor<?> targetDescriptor = Aura.getDefinitionService() .getDefDescriptor( String.format("%s:%s", namespace, name), type.getPrimaryInterface()); // Check if a single jstest is being requested. String testToRun = jstestToRun.get(request); if (testToRun != null && !testToRun.isEmpty()) { AuraContext context = Aura.getContextService().getCurrentContext(); Format format = context.getFormat(); switch (format) { case HTML: TestCaseDef testDef; TestContext testContext; String targetUri; try { TestSuiteDef suiteDef = getTestSuite(targetDescriptor); testDef = getTestCase(suiteDef, testToRun); testDef.validateDefinition(); testDef.setCurrentBrowser(browserType); testContextAdapter.getTestContext(testDef.getQualifiedName()); testContextAdapter.release(); testContext = testContextAdapter.getTestContext(testDef.getQualifiedName()); targetUri = buildJsTestTargetUri(targetDescriptor, testDef); } catch (QuickFixException e) { ((HttpServletResponse) res).setStatus(HttpStatus.SC_INTERNAL_SERVER_ERROR); res.setCharacterEncoding(AuraBaseServlet.UTF_ENCODING); res.getWriter().append(e.getMessage()); Aura.getExceptionAdapter().handleException(e); return; } // Load any test mocks. Collection<Definition> mocks = testDef.getLocalDefs(); testContext.getLocalDefs().addAll(mocks); loadTestMocks(context, true, testContext.getLocalDefs()); // Capture the response and inject tags to load jstest. String capturedResponse = captureResponse(req, res, targetUri); if (capturedResponse != null) { res.setCharacterEncoding(AuraBaseServlet.UTF_ENCODING); if (!Aura.getContextService().isEstablished()) { // There was an error in the original response, so just write the response out. res.getWriter().write(capturedResponse); } else { String testTag = buildJsTestScriptTag(targetDescriptor, testToRun, capturedResponse); injectScriptTags(res.getWriter(), capturedResponse, testTag); } return; } case JS: res.setCharacterEncoding(AuraBaseServlet.UTF_ENCODING); writeJsTestScript(res.getWriter(), targetDescriptor, testToRun); return; default: // Pass it on. } } // aurajstest:jstest app is invokable in the following ways: // ?aura.mode=JSTEST - run all tests // ?aura.mode JSTEST&test=XXX - run single test // ?aura.jstest - run all tests // ?aura.jstest=XXX - run single test // ?aura.jstestrun - run all tests // TODO: delete JSTEST mode String jstestAppRequest = jstestAppFlag.get(request); Mode mode = AuraContextFilter.mode.get(request, Mode.PROD); if (mode == Mode.JSTEST || mode == Mode.JSTESTDEBUG || jstestAppRequest != null || testToRun != null) { mode = mode.toString().endsWith("DEBUG") ? Mode.AUTOJSTESTDEBUG : Mode.AUTOJSTEST; String qs = String.format("descriptor=%s:%s&defType=%s", namespace, name, type.name()); String testName = null; if (jstestAppRequest != null && !jstestAppRequest.isEmpty()) { testName = jstestAppRequest; } else if (testToRun != null && !testToRun.isEmpty()) { testName = testToRun; } if (testName != null) { qs = qs + "&test=" + testName; } String newUri = createURI( "aurajstest", "jstest", DefType.APPLICATION, mode, Authentication.AUTHENTICATED.name(), qs); RequestDispatcher dispatcher = servletContext.getContext(newUri).getRequestDispatcher(newUri); if (dispatcher != null) { dispatcher.forward(req, res); return; } } } } // Handle mock definitions specified in the tests. TestContext testContext = getTestContext(request); if (testContext == null) { // During manual testing, the test context adapter may not always get cleared. testContextAdapter.clear(); } else { ContextService contextService = Aura.getContextService(); if (!contextService.isEstablished()) { LOG.error("Aura context is not established! New context will NOT be created."); chain.doFilter(req, res); return; } AuraContext context = contextService.getCurrentContext(); // Reset mocks if requested, or for the initial GET. boolean doResetMocks = testReset.get(request, Format.HTML.equals(context.getFormat())); loadTestMocks(context, doResetMocks, testContext.getLocalDefs()); } chain.doFilter(req, res); }
/** * Create a new bundle in a current namespace with a given name and type. * * <p>This should be used for the bundle-defining name, and subsequent calls should use the * descriptor form since this will create a new name. */ public <T extends Definition> DefDescriptor<T> getNewObject( String ns, Class<T> clazz, String contents) throws IOException { String name = getNewName(ns); String qualified = null; // FIXME: W-2368202 DefType defType = DefType.getDefType(clazz); switch (defType) { case CONTROLLER: case TESTSUITE: case MODEL: case RENDERER: case HELPER: case STYLE: case FLAVORED_STYLE: case RESOURCE: case TYPE: case PROVIDER: case TOKEN_DESCRIPTOR_PROVIDER: case TOKEN_MAP_PROVIDER: case INCLUDE: case REQUIRED_VERSION: qualified = String.format("%s.%s", ns, name); break; // subtypes case ACTION: case DESCRIPTION: case INCLUDE_REF: return null; case ATTRIBUTE: case LAYOUT: case LAYOUT_ITEM: case TESTCASE: case TOKEN: case TOKENS_IMPORT: case ATTRIBUTE_DESIGN: case DESIGN_TEMPLATE: case DESIGN_TEMPLATE_REGION: case FLAVOR_INCLUDE: case FLAVOR_DEFAULT: qualified = name; break; case APPLICATION: case COMPONENT: case INTERFACE: case EVENT: case LIBRARY: case DOCUMENTATION: case EXAMPLE: case LAYOUTS: case NAMESPACE: case TOKENS: case DESIGN: case SVG: case FLAVORS: case FLAVOR_ASSORTMENT: qualified = String.format("%s:%s", ns, name); break; default: break; } DefDescriptor<T> desc = Aura.getDefinitionService().getDefDescriptor(qualified, clazz); createFile(desc, contents); return desc; }
public ComponentDefModel() throws QuickFixException { AuraContext context = Aura.getContextService().getCurrentContext(); BaseComponent<?, ?> component = context.getCurrentComponent(); String desc = (String) component.getAttributes().getValue("descriptor"); DefType defType = DefType.valueOf(((String) component.getAttributes().getValue("defType")).toUpperCase()); DefinitionService definitionService = Aura.getDefinitionService(); descriptor = definitionService.getDefDescriptor(desc, defType.getPrimaryInterface()); definition = descriptor.getDef(); ReferenceTreeModel.assertAccess(definition); String type = null; if (definition instanceof RootDefinition) { RootDefinition rootDef = (RootDefinition) definition; for (AttributeDef attribute : rootDef.getAttributeDefs().values()) { if (ReferenceTreeModel.hasAccess(attribute)) { attributes.add(new AttributeModel(attribute)); } } DocumentationDef docDef = rootDef.getDocumentationDef(); doc = docDef != null ? new DocumentationDefModel(docDef) : null; if (definition instanceof BaseComponentDef) { BaseComponentDef cmpDef = (BaseComponentDef) definition; for (RegisterEventDef reg : cmpDef.getRegisterEventDefs().values()) { if (ReferenceTreeModel.hasAccess(reg)) { events.add(new AttributeModel(reg)); } } for (EventHandlerDef handler : cmpDef.getHandlerDefs()) { handledEvents.add(new AttributeModel(handler)); } for (DefDescriptor<InterfaceDef> intf : cmpDef.getInterfaces()) { if (ReferenceTreeModel.hasAccess(intf.getDef())) { interfaces.add(intf.getNamespace() + ":" + intf.getName()); } } DefDescriptor<?> superDesc = cmpDef.getExtendsDescriptor(); if (superDesc != null) { theSuper = superDesc.getNamespace() + ":" + superDesc.getName(); } else { theSuper = null; } isAbstract = cmpDef.isAbstract(); isExtensible = cmpDef.isExtensible(); } else if (definition instanceof EventDef) { EventDef eventDef = (EventDef) definition; DefDescriptor<?> superDesc = eventDef.getExtendsDescriptor(); if (superDesc != null) { theSuper = superDesc.getNamespace() + ":" + superDesc.getName(); } else { theSuper = null; } type = eventDef.getEventType().name(); isExtensible = true; isAbstract = false; } else { theSuper = null; isExtensible = true; isAbstract = false; } support = rootDef.getSupport().name(); if (definition instanceof RootDefinition) { List<DefDescriptor<?>> deps = ((RootDefinition) definition).getBundle(); for (DefDescriptor<?> dep : deps) { // we already surface the documentation--users don't need to see the source for it. if (dep.getDefType() != DefType.DOCUMENTATION) { Definition def = dep.getDef(); if (ReferenceTreeModel.hasAccess(def)) { defs.add(new DefModel(dep)); } } } } } else { support = null; theSuper = null; isExtensible = false; isAbstract = false; doc = null; } this.type = type; }