public class InstrumenterServiceTest {
  private InstrumenterService service = new InstrumenterService();
  private CompilerEnvirons compilerEnvirons = new CompilerEnvirons();
  private IoUtils ioUtils = IoUtils.getInstance();
  private File src = new File("target/src.js");

  @Before
  public void setUp() {
    src.delete();
    ioUtils.copy("x++;", src);
  }

  @Test
  public void shouldInstrumentForFileSystem() {
    File dest = new File("target/dest.js");
    dest.deleteOnExit();
    service.instrumentJSForFileSystem(compilerEnvirons, src, dest, "/src.js", false, false);
    String jsInstrumented = ioUtils.loadFromFileSystem(dest);

    assertThat(jsInstrumented, containsString("x++;"));
    assertThat(jsInstrumented, containsString("_$jscoverage['/src.js'].lineData[1]++;"));
  }

  @Test
  public void shouldInstrumentForWebServer() {
    File dest = new File("target/dest.js");
    dest.deleteOnExit();
    String jsInstrumented =
        service.instrumentJSForWebServer(compilerEnvirons, src, "/src.js", false, false);

    assertThat(jsInstrumented, containsString("x++;"));
    assertThat(jsInstrumented, containsString("_$jscoverage['/src.js'].lineData[1]++;"));
  }
}
  @Test
  public void shouldInstrumentForFileSystem() {
    File dest = new File("target/dest.js");
    dest.deleteOnExit();
    service.instrumentJSForFileSystem(compilerEnvirons, src, dest, "/src.js", false, false);
    String jsInstrumented = ioUtils.loadFromFileSystem(dest);

    assertThat(jsInstrumented, containsString("x++;"));
    assertThat(jsInstrumented, containsString("_$jscoverage['/src.js'].lineData[1]++;"));
  }
 public void saveJSONData(
     File reportDir,
     String data,
     List<ScriptCoverageCount> unloadJSData,
     UriFileTranslator uriFileTranslator) {
   try {
     lockOnReportDir(reportDir);
     reportDir.mkdirs();
     File jsonFile = new File(reportDir, "jscoverage.json");
     SortedMap<String, FileData> dataMap = new TreeMap<String, FileData>();
     if (jsonFile.exists()) {
       logger.info("Saving/merging JSON with existing JSON");
       String existingJSON = ioUtils.toString(jsonFile);
       if (uriFileTranslator.mutates()) {
         translateUris(data, uriFileTranslator, dataMap);
         dataMap =
             jsonDataMerger.mergeJSONCoverageMaps(dataMap, jsonDataMerger.jsonToMap(existingJSON));
       } else dataMap.putAll(jsonDataMerger.mergeJSONCoverageStrings(existingJSON, data));
       ioUtils.copy(jsonDataMerger.toJSON(dataMap), jsonFile);
     } else if (unloadJSData != null) {
       logger.info("Saving/merging JSON with unloaded JavaScript JSON");
       // Only scan for unloaded JS if JSON not saved before
       dataMap.putAll(jsonDataMerger.createEmptyJSON(unloadJSData));
       if (uriFileTranslator.mutates()) translateUris(data, uriFileTranslator, dataMap);
       else dataMap.putAll(jsonDataMerger.jsonToMap(data));
       ioUtils.copy(jsonDataMerger.toJSON(dataMap), jsonFile);
     } else {
       logger.info("Saving JSON");
       if (uriFileTranslator.mutates()) {
         translateUris(data, uriFileTranslator, dataMap);
         ioUtils.copy(jsonDataMerger.toJSON(dataMap), jsonFile);
       } else ioUtils.copy(data, jsonFile);
     }
   } finally {
     unlockOnReportDir(reportDir);
   }
 }
  @Test
  public void shouldIncludeUnloadJSInSavedReport() throws Exception {
    File jsonFile = new File(getReportDir() + "/jscoverage.json");
    if (jsonFile.exists()) jsonFile.delete();

    HtmlPage page = webClient.getPage("http://localhost:9001/jscoverage.html?index.html");

    page.getHtmlElementById("summaryTab").click();
    webClient.waitForBackgroundJavaScript(2000);
    assertEquals("77%", page.getElementById("summaryTotal").getTextContent());

    verifyCoverage(page, "/root.js", "80%", "50%", "100%");
    verifyCoverage(page, "/level1/level1.js", "75%", "50%", "N/A");

    page.getHtmlElementById("storeTab").click();
    webClient.waitForBackgroundJavaScript(500);
    HtmlElement storeButton = page.getHtmlElementById("storeButton");
    storeButton.click();
    webClient.waitForBackgroundJavaScript(2000);
    String result = page.getElementById("storeDiv").getTextContent();

    assertThat(
        result, containsString("Coverage data stored at " + new File(getReportDir()).getPath()));

    String json = ioUtils.toString(jsonFile);
    assertThat(json, containsString("/root.js"));
    assertThat(json, containsString("/level1/level2/level2.js"));

    String url = "file:///" + new File(getReportDir() + "/jscoverage.html").getAbsolutePath();
    page = webClient.getPage(url);
    webClient.waitForBackgroundJavaScript(1000);
    assertEquals("53%", page.getElementById("summaryTotal").getTextContent());
    assertEquals("33%", page.getElementById("branchSummaryTotal").getTextContent());
    assertEquals("50%", page.getElementById("functionSummaryTotal").getTextContent());
    verifyCoverage(page, "/root.js", "80%", "50%", "100%");
    verifyCoverage(page, "/level1/level1.js", "75%", "50%", "N/A");
    verifyCoverage(page, "/level1/level2/level2.js", "0%", "0%", "0%");
  }
 @AfterClass
 public static void tearDown() throws Exception {
   main.stop();
   IoUtils.getInstance().closeQuietly(serverSocket);
 }
public class PersistentProxyTest {
  private static Thread webServer;
  private static Thread proxyServer;
  private static Main main = new Main();
  private static ServerSocket serverSocket;
  private static int proxyPort = 3129;

  protected WebClient webClient = new WebClient();
  protected IoUtils ioUtils = IoUtils.getInstance();

  private static String CONTENT = "Some content";

  private static String[] args =
      new String[] {
        "-ws",
        "--port=" + proxyPort,
        "--proxy",
        "--no-branch",
        "--no-function",
        "--no-instrument-reg=.*",
      };

  @BeforeClass
  public static void setUpOnce() throws IOException {
    proxyServer =
        new Thread(
            new Runnable() {
              public void run() {
                main.runMain(args);
              }
            });
    proxyServer.start();
    webServer =
        new Thread(
            new Runnable() {
              public void run() {
                try {
                  serverSocket = new ServerSocket(9001);
                  while (true) {
                    final Socket socket = serverSocket.accept();
                    new Thread(new PersistentStaticHttpServer(socket, CONTENT)).start();
                  }
                } catch (IOException e) {
                  // throw new RuntimeException(e);
                }
              }
            });
    webServer.start();
  }

  @AfterClass
  public static void tearDown() throws Exception {
    main.stop();
    IoUtils.getInstance().closeQuietly(serverSocket);
  }

  @Before
  public void setUp() {
    ProxyConfig proxyConfig = new ProxyConfig("localhost", proxyPort);
    proxyConfig.addHostsToProxyBypass("127.0.0.1");
    webClient.getOptions().setProxyConfig(proxyConfig);
    webClient.getOptions().setTimeout(2000);
  }

  protected String getTestUrl() {
    return "http://localhost:9001/anything";
  }

  protected void doTestRequests(HttpMethod... methods) throws Exception {
    URL testURL = new URL(getTestUrl());
    for (HttpMethod method : methods) {
      WebRequest request = new WebRequest(testURL, method);
      Page page = webClient.getPage(request);
      assertEquals("Unexpected response", CONTENT, page.getWebResponse().getContentAsString());
    }
  }

  @Test
  public void testSingleGet() throws Exception {
    doTestRequests(HttpMethod.GET);
  }

  @Test
  public void testSinglePost() throws Exception {
    doTestRequests(HttpMethod.POST);
  }

  @Test
  public void testConsecutiveGets() throws Exception {
    doTestRequests(HttpMethod.GET, HttpMethod.GET);
  }

  @Test
  public void testConsecutivePosts() throws Exception {
    doTestRequests(HttpMethod.POST, HttpMethod.POST);
  }
}
 @Before
 public void setUp() {
   src.delete();
   ioUtils.copy("x++;", src);
 }
public class HtmlServerUnloadedJSTest {
  private static Thread server;

  protected WebClient webClient = new WebClient();
  private IoUtils ioUtils = IoUtils.getInstance();
  private String reportDir = "target/ws-report";
  private String[] args =
      new String[] {
        "-ws",
        "--document-root=src/test-integration/resources/jsSearch",
        "--port=9001",
        "--no-instrument=noInstrument",
        "--include-unloaded-js",
        "--report-dir=" + reportDir
      };

  @Before
  public void setUp() throws IOException {
    if (server == null) {
      server =
          new Thread(
              new Runnable() {
                public void run() {
                  try {
                    Main.main(args);
                  } catch (IOException e) {
                    throw new RuntimeException(e);
                  }
                }
              });
      server.start();
    }
    webClient.getOptions().setTimeout(30000);
  }

  @Test
  public void shouldIncludeUnloadJSInSavedReport() throws Exception {
    File jsonFile = new File(reportDir + "/jscoverage.json");
    if (jsonFile.exists()) jsonFile.delete();

    HtmlPage page = webClient.getPage("http://*****:*****@id='row-" + uri + "']/td[8]/span").getTextContent(),
        equalTo(linePercentage));
    assertThat(
        getHtmlElement(page, "//tr[@id='row-" + uri + "']/td[9]/span").getTextContent(),
        equalTo(branchPercentage));
    assertThat(
        getHtmlElement(page, "//tr[@id='row-" + uri + "']/td[10]/span").getTextContent(),
        equalTo(functionPercentage));
  }

  private HtmlElement getHtmlElement(HtmlPage page, String xpathExpr) {
    return (HtmlElement) ((ArrayList) page.getByXPath(xpathExpr)).get(0);
  }
}
public class JSONDataSaver {
  private static final Logger logger = Logger.getLogger(JSONDataSaver.class.getName());
  protected static Set<File> files = new HashSet<File>();
  private JSONDataMerger jsonDataMerger = new JSONDataMerger();
  private IoUtils ioUtils = IoUtils.getInstance();

  public void saveJSONData(
      File reportDir,
      String data,
      List<ScriptCoverageCount> unloadJSData,
      UriFileTranslator uriFileTranslator) {
    try {
      lockOnReportDir(reportDir);
      reportDir.mkdirs();
      File jsonFile = new File(reportDir, "jscoverage.json");
      SortedMap<String, FileData> dataMap = new TreeMap<String, FileData>();
      if (jsonFile.exists()) {
        logger.info("Saving/merging JSON with existing JSON");
        String existingJSON = ioUtils.toString(jsonFile);
        if (uriFileTranslator.mutates()) {
          translateUris(data, uriFileTranslator, dataMap);
          dataMap =
              jsonDataMerger.mergeJSONCoverageMaps(dataMap, jsonDataMerger.jsonToMap(existingJSON));
        } else dataMap.putAll(jsonDataMerger.mergeJSONCoverageStrings(existingJSON, data));
        ioUtils.copy(jsonDataMerger.toJSON(dataMap), jsonFile);
      } else if (unloadJSData != null) {
        logger.info("Saving/merging JSON with unloaded JavaScript JSON");
        // Only scan for unloaded JS if JSON not saved before
        dataMap.putAll(jsonDataMerger.createEmptyJSON(unloadJSData));
        if (uriFileTranslator.mutates()) translateUris(data, uriFileTranslator, dataMap);
        else dataMap.putAll(jsonDataMerger.jsonToMap(data));
        ioUtils.copy(jsonDataMerger.toJSON(dataMap), jsonFile);
      } else {
        logger.info("Saving JSON");
        if (uriFileTranslator.mutates()) {
          translateUris(data, uriFileTranslator, dataMap);
          ioUtils.copy(jsonDataMerger.toJSON(dataMap), jsonFile);
        } else ioUtils.copy(data, jsonFile);
      }
    } finally {
      unlockOnReportDir(reportDir);
    }
  }

  private void translateUris(
      String data, UriFileTranslator uriFileTranslator, SortedMap<String, FileData> map) {
    SortedMap<String, FileData> coverageData = jsonDataMerger.jsonToMap(data);
    for (String uri : coverageData.keySet())
      map.put(uriFileTranslator.convertUriToFile(uri), coverageData.get(uri));
  }

  private void lockOnReportDir(File reportDir) {
    synchronized (files) {
      while (files.contains(reportDir))
        try {
          files.wait();
        } catch (InterruptedException ex) {
          logger.log(SEVERE, Thread.currentThread().getName() + " INTERRUPTED", ex);
        }
      files.add(reportDir);
      files.notifyAll(); // must own the lock
    }
  }

  private void unlockOnReportDir(File reportDir) {
    synchronized (files) {
      files.remove(reportDir);
      files.notifyAll();
    }
  }
}
Exemple #10
0
 public void copyDir(File src, File dest) {
   if (src.isDirectory())
     for (String file : src.list()) copyDir(new File(src, file), new File(dest, file));
   else ioUtils.copy(src, dest);
 }