| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| */ |
| package org.apache.sling.discovery.impl.setup; |
| |
| import java.util.Calendar; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.HashSet; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import javax.jcr.Node; |
| import javax.jcr.PathNotFoundException; |
| import javax.jcr.Property; |
| import javax.jcr.PropertyIterator; |
| import javax.jcr.PropertyType; |
| import javax.jcr.RepositoryException; |
| import javax.jcr.Session; |
| |
| import org.apache.sling.api.resource.ModifiableValueMap; |
| import org.apache.sling.api.resource.SyntheticResource; |
| import org.apache.sling.api.resource.ValueMap; |
| import org.apache.sling.api.wrappers.ValueMapDecorator; |
| |
| // TODO this should come from a commons module, for now |
| // it's duplicated from the discovery module |
| public class MockedResource extends SyntheticResource { |
| |
| private final MockedResourceResolver mockedResourceResolver; |
| private Session session; |
| |
| public MockedResource(MockedResourceResolver resourceResolver, String path, |
| String resourceType) { |
| super(resourceResolver, path, resourceType); |
| mockedResourceResolver = resourceResolver; |
| |
| resourceResolver.register(this); |
| } |
| |
| private Session getSession() { |
| synchronized (this) { |
| if (session == null) { |
| try { |
| session = mockedResourceResolver.getSession(); |
| } catch (RepositoryException e) { |
| throw new RuntimeException("RepositoryException: " + e, e); |
| } |
| } |
| return session; |
| } |
| } |
| |
| @Override |
| protected void finalize() throws Throwable { |
| close(); |
| super.finalize(); |
| } |
| |
| public void close() { |
| synchronized (this) { |
| if (session != null) { |
| if (session.isLive()) { |
| session.logout(); |
| } |
| session = null; |
| } |
| } |
| } |
| |
| @SuppressWarnings("unchecked") |
| @Override |
| public <AdapterType> AdapterType adaptTo(Class<AdapterType> type) { |
| if (type.equals(Node.class)) { |
| try { |
| return (AdapterType) getSession().getNode(getPath()); |
| } catch (Exception e) { |
| throw new RuntimeException("Exception occurred: " + e, e); |
| } |
| } else if (type.equals(ValueMap.class)) { |
| try { |
| Session session = getSession(); |
| Node node = session.getNode(getPath()); |
| HashMap<String, Object> map = new HashMap<String, Object>(); |
| |
| PropertyIterator properties = node.getProperties(); |
| while (properties.hasNext()) { |
| Property p = properties.nextProperty(); |
| if (p.getType() == PropertyType.BOOLEAN) { |
| map.put(p.getName(), p.getBoolean()); |
| } else if (p.getType() == PropertyType.STRING) { |
| map.put(p.getName(), p.getString()); |
| } else if (p.getType() == PropertyType.DATE) { |
| map.put(p.getName(), p.getDate().getTime()); |
| } else if (p.getType() == PropertyType.NAME) { |
| map.put(p.getName(), p.getName()); |
| } else { |
| throw new RuntimeException( |
| "Unsupported property type: " + p.getType()); |
| } |
| } |
| ValueMap valueMap = new ValueMapDecorator(map); |
| return (AdapterType) valueMap; |
| } catch (Exception e) { |
| e.printStackTrace(); |
| return null; |
| } |
| } else if (type.equals(ModifiableValueMap.class)) { |
| return (AdapterType) new ModifiableValueMap() { |
| |
| public Collection<Object> values() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public int size() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public Object remove(Object arg0) { |
| Session session = getSession(); |
| try{ |
| final Node node = session.getNode(getPath()); |
| final Property p = node.getProperty(String.valueOf(arg0)); |
| if (p!=null) { |
| p.remove(); |
| } |
| // this is not according to the spec - but OK for tests since |
| // the return value is never used |
| return null; |
| } catch(PathNotFoundException pnfe) { |
| // perfectly fine |
| return null; |
| } catch(RepositoryException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| public void putAll(Map<? extends String, ? extends Object> arg0) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public Object put(String arg0, Object arg1) { |
| Session session = getSession(); |
| try{ |
| final Node node = session.getNode(getPath()); |
| Object result = null; |
| if (node.hasProperty(arg0)) { |
| final Property previous = node.getProperty(arg0); |
| if (previous==null) { |
| // null |
| } else if (previous.getType() == PropertyType.STRING) { |
| result = previous.getString(); |
| } else if (previous.getType() == PropertyType.DATE) { |
| result = previous.getDate(); |
| } else if (previous.getType() == PropertyType.BOOLEAN) { |
| result = previous.getBoolean(); |
| } else { |
| throw new UnsupportedOperationException(); |
| } |
| } |
| if (arg1 instanceof String) { |
| node.setProperty(arg0, (String)arg1); |
| } else if (arg1 instanceof Long) { |
| node.setProperty(arg0, (Long)arg1); |
| } else if (arg1 instanceof Calendar) { |
| node.setProperty(arg0, (Calendar)arg1); |
| } else if (arg1 instanceof Boolean) { |
| node.setProperty(arg0, (Boolean)arg1); |
| } else { |
| throw new UnsupportedOperationException(); |
| } |
| return result; |
| } catch(RepositoryException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| public Set<String> keySet() { |
| Session session = getSession(); |
| try { |
| final Node node = session.getNode(getPath()); |
| final PropertyIterator pi = node.getProperties(); |
| final Set<String> result = new HashSet<String>(); |
| while(pi.hasNext()) { |
| final Property p = pi.nextProperty(); |
| result.add(p.getName()); |
| } |
| return result; |
| } catch (RepositoryException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| |
| public boolean isEmpty() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public Object get(Object arg0) { |
| try { |
| Node node = session.getNode(getPath()); |
| return node.getProperty(String.valueOf(arg0)); |
| } catch (PathNotFoundException e) { |
| return null; |
| } catch (RepositoryException e) { |
| e.printStackTrace(); |
| throw new RuntimeException(); |
| } |
| // throw new UnsupportedOperationException(); |
| } |
| |
| public Set<Entry<String, Object>> entrySet() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public boolean containsValue(Object arg0) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public boolean containsKey(Object arg0) { |
| Session session = getSession(); |
| try{ |
| final Node node = session.getNode(getPath()); |
| return node.hasProperty(String.valueOf(arg0)); |
| } catch(RepositoryException re) { |
| throw new RuntimeException(re); |
| } |
| } |
| |
| public void clear() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public <T> T get(String name, T defaultValue) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| public <T> T get(String name, Class<T> type) { |
| Session session = getSession(); |
| try{ |
| final Node node = session.getNode(getPath()); |
| if (node==null) { |
| return null; |
| } |
| Property p = node.getProperty(name); |
| if (p==null) { |
| return null; |
| } |
| if (type.equals(Calendar.class)) { |
| return (T) p.getDate(); |
| } else if (type.equals(String.class)) { |
| return (T) p.getString(); |
| } else { |
| throw new UnsupportedOperationException(); |
| } |
| } catch(RepositoryException e) { |
| throw new RuntimeException(e); |
| } |
| } |
| }; |
| } else { |
| return super.adaptTo(type); |
| } |
| } |
| |
| } |