@Test
  public void testGetEntityDefinition() throws Exception {
    ClientResponse response;
    Map<String, String> overlay = getUniqueOverlay();

    response = submitToIvory(CLUSTER_FILE_TEMPLATE, overlay, EntityType.CLUSTER);
    assertSuccessful(response);

    response = submitToIvory(FEED_TEMPLATE1, overlay, EntityType.FEED);
    assertSuccessful(response);

    response =
        this.service
            .path("api/entities/definition/feed/" + overlay.get("inputFeedName"))
            .header("Remote-User", REMOTE_USER)
            .accept(MediaType.TEXT_XML)
            .get(ClientResponse.class);

    String feedXML = response.getEntity(String.class);
    try {
      Feed result = (Feed) unmarshaller.unmarshal(new StringReader(feedXML));
      Assert.assertEquals(result.getName(), overlay.get("inputFeedName"));
    } catch (JAXBException e) {
      Assert.fail("Reponse " + feedXML + " is not valid", e);
    }
  }
  /**
   * Tests should be enabled only in local environments as they need running instance of webserver
   */
  @Test
  public void testUpdateCheckUser() throws Exception {
    Map<String, String> overlay = getUniqueOverlay();
    String tmpFileName = overlayParametersOverTemplate(PROCESS_TEMPLATE, overlay);
    Process process =
        (Process) EntityType.PROCESS.getUnmarshaller().unmarshal(new File(tmpFileName));
    Validity processValidity = process.getClusters().getClusters().get(0).getValidity();
    processValidity.setEnd(new Date(new Date().getTime() + 2 * 24 * 60 * 60 * 1000));
    File tmpFile = getTempFile();
    EntityType.PROCESS.getMarshaller().marshal(process, tmpFile);
    scheduleProcess(tmpFile.getAbsolutePath(), overlay);
    waitForBundleStart(Status.RUNNING);

    List<BundleJob> bundles = getBundles();
    Assert.assertEquals(bundles.size(), 1);
    Assert.assertEquals(bundles.get(0).getUser(), REMOTE_USER);

    ClientResponse response =
        this.service
            .path("api/entities/definition/feed/" + outputFeedName)
            .header("Remote-User", REMOTE_USER)
            .accept(MediaType.TEXT_XML)
            .get(ClientResponse.class);
    Feed feed =
        (Feed)
            EntityType.FEED
                .getUnmarshaller()
                .unmarshal(new StringReader(response.getEntity(String.class)));

    // change output feed path and update feed as another user
    feed.getLocations()
        .getLocations()
        .get(0)
        .setPath("/ivory/test/output2/${YEAR}/${MONTH}/${DAY}");
    tmpFile = getTempFile();
    EntityType.FEED.getMarshaller().marshal(feed, tmpFile);
    response =
        this.service
            .path("api/entities/update/feed/" + outputFeedName)
            .header("Remote-User", "testuser")
            .accept(MediaType.TEXT_XML)
            .post(ClientResponse.class, getServletInputStream(tmpFile.getAbsolutePath()));
    assertSuccessful(response);

    bundles = getBundles();
    Assert.assertEquals(bundles.size(), 2);
    Assert.assertEquals(bundles.get(0).getUser(), REMOTE_USER);
    Assert.assertEquals(bundles.get(1).getUser(), REMOTE_USER);
  }
Example #3
0
  @Test
  public void testShouldUpdate2() throws Exception {
    Feed oldFeed = parser.parseAndValidate(this.getClass().getResourceAsStream(FEED_XML));
    String cluster = "testCluster";
    Feed newFeed = (Feed) oldFeed.clone();
    Assert.assertFalse(UpdateHelper.shouldUpdate(oldFeed, newFeed, cluster));

    newFeed.setGroups("newgroups");
    Assert.assertFalse(UpdateHelper.shouldUpdate(oldFeed, newFeed, cluster));
    newFeed.getLateArrival().setCutOff(Frequency.fromString("hours(8)"));
    Assert.assertFalse(UpdateHelper.shouldUpdate(oldFeed, newFeed, cluster));
    newFeed.setFrequency(Frequency.fromString("days(1)"));
    Assert.assertTrue(UpdateHelper.shouldUpdate(oldFeed, newFeed, cluster));

    Process oldProcess =
        processParser.parseAndValidate(this.getClass().getResourceAsStream(PROCESS_XML));
    Process newProcess = (Process) oldProcess.clone();

    newProcess.getRetry().setPolicy(PolicyType.FINAL);
    Assert.assertFalse(UpdateHelper.shouldUpdate(oldProcess, newProcess, cluster));
    newProcess.getLateProcess().getLateInputs().remove(1);
    Assert.assertFalse(UpdateHelper.shouldUpdate(oldProcess, newProcess, cluster));
    newProcess.getLateProcess().setPolicy(PolicyType.PERIODIC);
    Assert.assertFalse(UpdateHelper.shouldUpdate(oldProcess, newProcess, cluster));
    newProcess.setFrequency(Frequency.fromString("days(1)"));
    Assert.assertTrue(UpdateHelper.shouldUpdate(oldProcess, newProcess, cluster));
  }
Example #4
0
  @Test
  public void testShouldUpdate() throws Exception {
    Feed oldFeed = parser.parseAndValidate(this.getClass().getResourceAsStream(FEED_XML));

    Feed newFeed = (Feed) oldFeed.clone();
    Process process =
        processParser.parseAndValidate(this.getClass().getResourceAsStream(PROCESS_XML));

    Assert.assertFalse(UpdateHelper.shouldUpdate(oldFeed, newFeed, process));

    newFeed.getLateArrival().setCutOff(Frequency.fromString("hours(1)"));
    Assert.assertFalse(UpdateHelper.shouldUpdate(oldFeed, newFeed, process));

    newFeed.getLateArrival().setCutOff(oldFeed.getLateArrival().getCutOff());
    Assert.assertFalse(UpdateHelper.shouldUpdate(oldFeed, newFeed, process));

    FeedHelper.getLocation(newFeed, LocationType.DATA).setPath("/test");
    Assert.assertTrue(UpdateHelper.shouldUpdate(oldFeed, newFeed, process));

    FeedHelper.getLocation(newFeed, LocationType.DATA)
        .setPath(FeedHelper.getLocation(oldFeed, LocationType.DATA).getPath());
    Assert.assertFalse(UpdateHelper.shouldUpdate(oldFeed, newFeed, process));

    newFeed.setFrequency(Frequency.fromString("months(1)"));
    Assert.assertTrue(UpdateHelper.shouldUpdate(oldFeed, newFeed, process));

    newFeed.setFrequency(oldFeed.getFrequency());
    Assert.assertFalse(UpdateHelper.shouldUpdate(oldFeed, newFeed, process));

    Partition partition = new Partition();
    partition.setName("1");
    newFeed.getPartitions().getPartitions().add(partition);
    Assert.assertFalse(UpdateHelper.shouldUpdate(oldFeed, newFeed, process));

    Property property = new Property();
    property.setName("1");
    property.setValue("1");
    newFeed.setProperties(new Properties());
    newFeed.getProperties().getProperties().add(property);
    Assert.assertFalse(UpdateHelper.shouldUpdate(oldFeed, newFeed, process));

    newFeed.getProperties().getProperties().remove(0);
    Assert.assertFalse(UpdateHelper.shouldUpdate(oldFeed, newFeed, process));

    FeedHelper.getCluster(newFeed, process.getClusters().getClusters().get(0).getName())
        .getValidity()
        .setStart(SchemaHelper.parseDateUTC("2012-11-01T00:00Z"));
    Assert.assertTrue(UpdateHelper.shouldUpdate(oldFeed, newFeed, process));

    FeedHelper.getCluster(newFeed, process.getClusters().getClusters().get(0).getName())
        .getValidity()
        .setStart(
            FeedHelper.getCluster(oldFeed, process.getClusters().getClusters().get(0).getName())
                .getValidity()
                .getStart());
    Assert.assertFalse(UpdateHelper.shouldUpdate(oldFeed, newFeed, process));
  }