/**
   * Add ETag and Last-Modified cache control headers to the response
   *
   * @param servletResponse the servlet response
   * @param resource the fedora resource
   * @param session the session
   */
  protected static void addCacheControlHeaders(
      final HttpServletResponse servletResponse,
      final FedoraResource resource,
      final Session session) {

    final String txId = TransactionServiceImpl.getCurrentTransactionId(session);
    if (txId != null) {
      // Do not add caching headers if in a transaction
      return;
    }

    final FedoraResource mutableResource =
        resource instanceof NonRdfSourceDescription
            ? ((NonRdfSourceDescription) resource).getDescribedResource()
            : resource;
    final EntityTag etag = new EntityTag(mutableResource.getEtagValue());
    final Date date = mutableResource.getLastModifiedDate();

    if (!etag.getValue().isEmpty()) {
      servletResponse.addHeader("ETag", etag.toString());
    }

    if (date != null) {
      servletResponse.addDateHeader("Last-Modified", date.getTime());
    }
  }
Пример #2
0
 @Before
 public void setUp() throws Exception {
   initMocks(this);
   when(mockResource.getPath()).thenReturn(testPath);
   when(mockResource.getNode()).thenReturn(mockNode);
   when(mockNode.getSession()).thenReturn(mockSession);
 }
Пример #3
0
  @Test
  public void testChildren() throws RepositoryException {
    when(mockRes1.getPath()).thenReturn(RDF_PATH + "/res1");
    when(mockRes2.getPath()).thenReturn(RDF_PATH + "/res2");
    when(mockRes3.getPath()).thenReturn(RDF_PATH + "/res3");
    when(mockResourceNode.hasNodes()).thenReturn(true);
    final Stream<FedoraResource> first = of(mockRes1, mockRes2, mockRes3);
    final Stream<FedoraResource> second = of(mockRes1, mockRes2, mockRes3);
    when(mockResource.getChildren()).thenReturn(first).thenReturn(second);

    try (final ChildrenRdfContext context = new ChildrenRdfContext(mockResource, idTranslator)) {
      final Model results = context.collect(toModel());
      final Resource subject = idTranslator.reverse().convert(mockResource);

      final StmtIterator stmts =
          results.listStatements(subject, RdfLexicon.HAS_CHILD_COUNT, (RDFNode) null);

      assertTrue("There should have been a statement!", stmts.hasNext());
      final Statement stmt = stmts.nextStatement();
      assertTrue("Object should be a literal! " + stmt.getObject(), stmt.getObject().isLiteral());
      assertEquals(3, stmt.getInt());

      assertFalse("There should not have been a second statement!", stmts.hasNext());
    }
  }
Пример #4
0
  @Override
  public FedoraResource getVersionedAncestor() {

    try {
      if (!isFrozenResource()) {
        return null;
      }

      Node versionableFrozenNode = getNode();
      FedoraResource unfrozenResource = getUnfrozenResource();

      // traverse the frozen tree looking for a node whose unfrozen equivalent is versioned
      while (!unfrozenResource.isVersioned()) {

        if (versionableFrozenNode.getDepth() == 0) {
          return null;
        }

        // node in the frozen tree
        versionableFrozenNode = versionableFrozenNode.getParent();

        // unfrozen equivalent
        unfrozenResource = new FedoraResourceImpl(versionableFrozenNode).getUnfrozenResource();
      }

      return new FedoraResourceImpl(versionableFrozenNode);
    } catch (final RepositoryException e) {
      throw new RepositoryRuntimeException(e);
    }
  }
Пример #5
0
  @Before
  public void setUp() throws RepositoryException {
    // Mock RDF Source
    when(mockResource.getNode()).thenReturn(mockResourceNode);
    when(mockResourceNode.getSession()).thenReturn(mockSession);
    when(mockResource.getPath()).thenReturn(RDF_PATH);

    idTranslator = new DefaultIdentifierTranslator(mockSession);
  }
 @Test
 public void verifyThatPropertiesAreExternal() throws RepositoryException {
   final Session session = repo.login();
   try {
     final FedoraResource object = nodeService.find(session, testFilePath());
     assertEquals(
         "There should be exactly as many visible nodes as actual files (ie, no hidden sidecar files).",
         fileForNode().getParentFile().list().length,
         getChildCount(object.getNode().getParent()));
   } finally {
     session.logout();
   }
 }
  @Test
  public void noAclTest1() throws RepositoryException {
    final String agent1 = "http://xmlns.com/foaf/0.1/Agent";

    when(mockResource.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(new RdfStream());
    when(mockResource.getPath()).thenReturn("/");
    when(mockResource.getTypes())
        .thenReturn(Arrays.asList(URI.create(REPOSITORY_NAMESPACE + "Resource")));
    final Map<String, List<String>> roles = roleProvider.getRoles(mockNode, true);

    assertEquals("There should be exactly one agent", 1, roles.size());
    assertEquals("The agent should have zero modes", 0, roles.get(agent1).size());
  }
  protected void replaceResourceWithStream(
      final FedoraResource resource,
      final InputStream requestBodyStream,
      final MediaType contentType,
      final RdfStream resourceTriples)
      throws MalformedRdfException {
    final Lang format = contentTypeToLang(contentType.toString());

    final Model inputModel = createDefaultModel();
    try {
      inputModel.read(
          requestBodyStream, getUri(resource).toString(), format.getName().toUpperCase());

    } catch (final RiotException e) {
      throw new BadRequestException("RDF was not parsable: " + e.getMessage(), e);

    } catch (final RuntimeIOException e) {
      if (e.getCause() instanceof JsonParseException) {
        throw new MalformedRdfException(e.getCause());
      }
      throw new RepositoryRuntimeException(e);
    }

    resource.replaceProperties(translator(), inputModel, resourceTriples);
  }
  private static void evaluateRequestPreconditions(
      final Request request,
      final HttpServletResponse servletResponse,
      final FedoraResource resource,
      final Session session,
      final boolean cacheControl) {

    final String txId = TransactionServiceImpl.getCurrentTransactionId(session);
    if (txId != null) {
      // Force cache revalidation if in a transaction
      servletResponse.addHeader(CACHE_CONTROL, "must-revalidate");
      servletResponse.addHeader(CACHE_CONTROL, "max-age=0");
      return;
    }

    final EntityTag etag = new EntityTag(resource.getEtagValue());
    final Date date = resource.getLastModifiedDate();
    final Date roundedDate = new Date();

    if (date != null) {
      roundedDate.setTime(date.getTime() - date.getTime() % 1000);
    }

    Response.ResponseBuilder builder = request.evaluatePreconditions(etag);
    if (builder != null) {
      builder = builder.entity("ETag mismatch");
    } else {
      builder = request.evaluatePreconditions(roundedDate);
      if (builder != null) {
        builder = builder.entity("Date mismatch");
      }
    }

    if (builder != null && cacheControl) {
      final CacheControl cc = new CacheControl();
      cc.setMaxAge(0);
      cc.setMustRevalidate(true);
      // here we are implicitly emitting a 304
      // the exception is not an error, it's genuinely
      // an exceptional condition
      builder = builder.cacheControl(cc).lastModified(date).tag(etag);
    }
    if (builder != null) {
      throw new WebApplicationException(builder.build());
    }
  }
  @Test
  public void acl02Test() throws RepositoryException {
    final String agent = "Editors";
    final String accessTo = "/box/bag/collection";
    final String acl = "/acls/02";
    final String auth = acl + "/authorization.ttl";

    when(mockNodeService.find(mockSession, acl)).thenReturn(mockAclResource);
    when(mockProperty.getString()).thenReturn(acl);
    when(mockAclResource.getPath()).thenReturn(acl);
    when(mockResource.getPath()).thenReturn(accessTo);
    when(mockResource.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(getResourceRdfStream(accessTo, acl));

    when(mockAuthorizationResource1.getTypes()).thenReturn(Arrays.asList(WEBAC_AUTHORIZATION));
    when(mockAuthorizationResource1.getPath()).thenReturn(auth);
    when(mockAuthorizationResource1.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(getRdfStreamFromResource(auth, TTL));

    when(mockAclResource.getChildren())
        .thenReturn(Arrays.asList(mockAuthorizationResource1).iterator());

    final Map<String, List<String>> roles = roleProvider.getRoles(mockNode, true);

    assertEquals("There should be exactly one agent in the role map", 1, roles.size());
    assertEquals("The agent should have exactly two modes", 2, roles.get(agent).size());
    assertTrue(
        "The agent should be able to read", roles.get(agent).contains(WEBAC_MODE_READ_VALUE));
    assertTrue(
        "The agent should be able to write", roles.get(agent).contains(WEBAC_MODE_WRITE_VALUE));
  }
  @Test
  public void acl01Test2() throws RepositoryException {
    final String accessTo = "/webacl_box2";
    final String acl = "/acls/01";
    final String auth = acl + "/authorization.ttl";

    when(mockNodeService.find(mockSession, acl)).thenReturn(mockAclResource);
    when(mockProperty.getString()).thenReturn(acl);
    when(mockAclResource.getPath()).thenReturn(acl);
    when(mockResource.getPath()).thenReturn(accessTo);
    when(mockResource.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(getResourceRdfStream(accessTo, acl));

    when(mockAuthorizationResource1.getTypes()).thenReturn(Arrays.asList(WEBAC_AUTHORIZATION));
    when(mockAuthorizationResource1.getPath()).thenReturn(auth);
    when(mockAuthorizationResource1.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(getRdfStreamFromResource(auth, TTL));

    when(mockAclResource.getChildren())
        .thenReturn(Arrays.asList(mockAuthorizationResource1).iterator());

    final Map<String, List<String>> roles = roleProvider.getRoles(mockNode, true);

    assertTrue("There should be no agents associated with this object", roles.isEmpty());
  }
  @Test
  public void noAclTestMalformedRdf2() throws RepositoryException {
    final String agent1 = "http://xmlns.com/foaf/0.1/Agent";

    when(mockResource.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(new RdfStream());
    when(mockResource.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(new RdfStream());
    when(mockResource.getPath()).thenReturn("/");
    when(mockResource.getTypes())
        .thenReturn(Arrays.asList(URI.create(REPOSITORY_NAMESPACE + "Resource")));

    System.setProperty(ROOT_AUTHORIZATION_PROPERTY, "./target/test-classes/logback-test.xml");
    final Map<String, List<String>> roles = roleProvider.getRoles(mockNode, true);
    System.clearProperty(ROOT_AUTHORIZATION_PROPERTY);

    assertEquals("There should be exactly one agent", 1, roles.size());
    assertEquals("The agent should have zero modes", 0, roles.get(agent1).size());
  }
  @Test
  public void noAclTest() throws RepositoryException {
    final String accessTo = "/dark/archive/sunshine";

    when(mockResource.getPath()).thenReturn(accessTo);
    when(mockResource.getContainer()).thenReturn(mockParentResource);
    when(mockResource.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(new RdfStream());
    when(mockNode.getDepth()).thenReturn(1);

    when(mockParentResource.getNode()).thenReturn(mockParentNode);
    when(mockParentResource.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(new RdfStream());
    when(mockParentNode.getDepth()).thenReturn(0);

    final Map<String, List<String>> roles = roleProvider.getRoles(mockNode, true);

    assertTrue("There should be no agents in the roles map", roles.isEmpty());
  }
  @Test
  public void acl04Test() throws RepositoryException {
    final String agent1 = "http://xmlns.com/foaf/0.1/Agent";
    final String agent2 = "Editors";
    final String accessTo = "/public_collection";
    final String acl = "/acls/04";
    final String auth1 = acl + "/auth1.ttl";
    final String auth2 = acl + "/auth2.ttl";

    when(mockNodeService.find(mockSession, acl)).thenReturn(mockAclResource);
    when(mockProperty.getString()).thenReturn(acl);
    when(mockAclResource.getPath()).thenReturn(acl);
    when(mockResource.getPath()).thenReturn(accessTo);
    when(mockResource.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(getResourceRdfStream(accessTo, acl));

    when(mockAuthorizationResource1.getTypes()).thenReturn(Arrays.asList(WEBAC_AUTHORIZATION));
    when(mockAuthorizationResource1.getPath()).thenReturn(auth1);
    when(mockAuthorizationResource1.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(getRdfStreamFromResource(auth1, TTL));

    when(mockAuthorizationResource2.getTypes()).thenReturn(Arrays.asList(WEBAC_AUTHORIZATION));
    when(mockAuthorizationResource2.getPath()).thenReturn(auth2);
    when(mockAuthorizationResource2.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(getRdfStreamFromResource(auth2, TTL));

    when(mockAclResource.getChildren())
        .thenReturn(
            Arrays.asList(mockAuthorizationResource1, mockAuthorizationResource2).iterator());

    final Map<String, List<String>> roles = roleProvider.getRoles(mockNode, true);

    assertEquals("There should be exactly two agents", 2, roles.size());
    assertEquals("The agent should have one mode", 1, roles.get(agent1).size());
    assertTrue(
        "The agent should be able to read", roles.get(agent1).contains(WEBAC_MODE_READ_VALUE));
    assertEquals("The agent should have two modes", 2, roles.get(agent2).size());
    assertTrue(
        "The agent should be able to read", roles.get(agent2).contains(WEBAC_MODE_READ_VALUE));
    assertTrue(
        "The agent should be able to write", roles.get(agent2).contains(WEBAC_MODE_READ_VALUE));
  }
  @Test
  public void noAclTestOkRdf3() throws RepositoryException {
    final String agent1 = "testAdminUser";

    when(mockResource.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(new RdfStream());
    when(mockResource.getPath()).thenReturn("/");
    when(mockResource.getTypes())
        .thenReturn(Arrays.asList(URI.create(REPOSITORY_NAMESPACE + "Resource")));

    System.setProperty(
        ROOT_AUTHORIZATION_PROPERTY, "./target/test-classes/test-root-authorization.ttl");
    final Map<String, List<String>> roles = roleProvider.getRoles(mockNode, true);
    System.clearProperty(ROOT_AUTHORIZATION_PROPERTY);

    assertEquals("There should be exactly one agent", 1, roles.size());
    assertEquals("The agent should have one mode", 1, roles.get(agent1).size());
    assertTrue(
        "The agent should be able to read", roles.get(agent1).contains(WEBAC_MODE_READ_VALUE));
  }
 protected void patchResourcewithSparql(
     final FedoraResource resource, final String requestBody, final RdfStream resourceTriples)
     throws MalformedRdfException, AccessDeniedException {
   if (resource instanceof NonRdfSourceDescription) {
     // update the described resource instead
     ((NonRdfSourceDescription) resource)
         .getDescribedResource()
         .updateProperties(translator(), requestBody, resourceTriples);
   } else {
     resource.updateProperties(translator(), requestBody, resourceTriples);
   }
 }
  /**
   * Add any resource-specific headers to the response
   *
   * @param resource the resource
   */
  protected void addResourceHttpHeaders(final FedoraResource resource) {
    if (resource instanceof FedoraBinary) {

      final FedoraBinary binary = (FedoraBinary) resource;
      final ContentDisposition contentDisposition =
          ContentDisposition.type("attachment")
              .fileName(binary.getFilename())
              .creationDate(binary.getCreatedDate())
              .modificationDate(binary.getLastModifiedDate())
              .size(binary.getContentSize())
              .build();

      servletResponse.addHeader("Content-Type", binary.getMimeType());
      servletResponse.addHeader("Content-Length", String.valueOf(binary.getContentSize()));
      servletResponse.addHeader("Accept-Ranges", "bytes");
      servletResponse.addHeader("Content-Disposition", contentDisposition.toString());
    }

    servletResponse.addHeader("Link", "<" + LDP_NAMESPACE + "Resource>;rel=\"type\"");

    if (resource instanceof NonRdfSource) {
      servletResponse.addHeader("Link", "<" + LDP_NAMESPACE + "NonRDFSource>;rel=\"type\"");
    } else if (resource instanceof Container) {
      servletResponse.addHeader("Link", "<" + CONTAINER.getURI() + ">;rel=\"type\"");
      if (resource.hasType(LDP_BASIC_CONTAINER)) {
        servletResponse.addHeader("Link", "<" + BASIC_CONTAINER.getURI() + ">;rel=\"type\"");
      } else if (resource.hasType(LDP_DIRECT_CONTAINER)) {
        servletResponse.addHeader("Link", "<" + DIRECT_CONTAINER.getURI() + ">;rel=\"type\"");
      } else if (resource.hasType(LDP_INDIRECT_CONTAINER)) {
        servletResponse.addHeader("Link", "<" + INDIRECT_CONTAINER.getURI() + ">;rel=\"type\"");
      } else {
        servletResponse.addHeader("Link", "<" + BASIC_CONTAINER.getURI() + ">;rel=\"type\"");
      }
    } else {
      servletResponse.addHeader("Link", "<" + LDP_NAMESPACE + "RDFSource>;rel=\"type\"");
    }
    if (httpHeaderInject != null) {
      httpHeaderInject.addHttpHeaderToResponseStream(servletResponse, uriInfo, resource());
    }
  }
  @Before
  public void setUp() throws RepositoryException {

    roleProvider = new WebACRolesProvider();
    setField(roleProvider, "nodeService", mockNodeService);
    setField(roleProvider, "sessionFactory", mockSessionFactory);

    when(mockNodeService.cast(mockNode)).thenReturn(mockResource);
    when(mockNode.getSession()).thenReturn(mockSession);
    when(mockSessionFactory.getInternalSession()).thenReturn(mockSession);

    when(mockResource.getNode()).thenReturn(mockNode);
    when(mockNode.getDepth()).thenReturn(0);
  }
  @Test
  public void acl03Test2() throws RepositoryException {
    final String agent = "Restricted";
    final String accessTo = "/dark/archive";
    final String acl = "/acls/03";
    final String auth1 = acl + "/auth_restricted.ttl";
    final String auth2 = acl + "/auth_open.ttl";

    when(mockNodeService.find(mockSession, acl)).thenReturn(mockAclResource);
    when(mockProperty.getString()).thenReturn(acl);
    when(mockAclResource.getPath()).thenReturn(acl);
    when(mockResource.getPath()).thenReturn(accessTo);
    when(mockResource.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(getResourceRdfStream(accessTo, acl));

    when(mockAuthorizationResource1.getTypes()).thenReturn(Arrays.asList(WEBAC_AUTHORIZATION));
    when(mockAuthorizationResource1.getPath()).thenReturn(auth1);
    when(mockAuthorizationResource1.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(getRdfStreamFromResource(auth1, TTL));

    when(mockAuthorizationResource2.getTypes()).thenReturn(Arrays.asList(WEBAC_AUTHORIZATION));
    when(mockAuthorizationResource2.getPath()).thenReturn(auth2);
    when(mockAuthorizationResource2.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(getRdfStreamFromResource(auth2, TTL));

    when(mockAclResource.getChildren())
        .thenReturn(
            Arrays.asList(mockAuthorizationResource1, mockAuthorizationResource2).iterator());

    final Map<String, List<String>> roles = roleProvider.getRoles(mockNode, true);

    assertEquals("There should be exactly one agent", 1, roles.size());
    assertEquals("The agent should have one mode", 1, roles.get(agent).size());
    assertTrue(
        "The agent should be able to read", roles.get(agent).contains(WEBAC_MODE_READ_VALUE));
  }
  /* (non-Javadoc)
   * Test that an in-repository resource used as a target for acl:agentClass has
   * the rdf:type of foaf:Group. This test mocks a resource that is not of the type
   * foaf:Group and therefore should retrieve zero agents.
   */
  @Test
  public void acl09Test2() throws RepositoryException {
    final String agent1 = "person1";
    final String agent2 = "person2";
    final String accessTo = "/anotherCollection";

    final String groupResource = "/group/foo";
    final String acl = "/acls/09";
    final String auth = acl + "/authorization.ttl";
    final String group = acl + "/group.ttl";

    when(mockNodeService.find(mockSession, acl)).thenReturn(mockAclResource);
    when(mockNodeService.find(mockSession, groupResource)).thenReturn(mockAgentClassResource);
    when(mockProperty.getString()).thenReturn(acl);
    when(mockAclResource.getPath()).thenReturn(acl);
    when(mockResource.getPath()).thenReturn(accessTo);
    when(mockResource.getTypes()).thenReturn(new ArrayList<>());
    when(mockResource.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(getResourceRdfStream(accessTo, acl));

    when(mockAuthorizationResource1.getTypes()).thenReturn(Arrays.asList(WEBAC_AUTHORIZATION));
    when(mockAuthorizationResource1.getPath()).thenReturn(auth);
    when(mockAuthorizationResource1.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(getRdfStreamFromResource(auth, TTL));

    when(mockAgentClassResource.getTypes()).thenReturn(new ArrayList<>());
    when(mockAgentClassResource.getPath()).thenReturn(groupResource);
    when(mockAgentClassResource.getTriples(anyObject(), eq(PropertiesRdfContext.class)))
        .thenReturn(getRdfStreamFromResource(group, TTL));

    when(mockAclResource.getChildren())
        .thenReturn(Arrays.asList(mockAuthorizationResource1).iterator());

    final Map<String, List<String>> roles = roleProvider.getRoles(mockNode, true);

    assertEquals("There should be exactly zero agents", 0, roles.size());
  }
 protected RdfStream getTriples(
     final FedoraResource resource, final Class<? extends RdfStream> x) {
   return resource.getTriples(translator(), x);
 }