| /**************************************************************** |
| * 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.jsieve.javaxmail; |
| |
| import java.io.ByteArrayInputStream; |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.OutputStream; |
| import java.io.UnsupportedEncodingException; |
| import java.util.ArrayList; |
| import java.util.Arrays; |
| import java.util.Collection; |
| import java.util.Collections; |
| import java.util.Date; |
| import java.util.Enumeration; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| |
| import javax.activation.DataHandler; |
| import javax.mail.Address; |
| import javax.mail.Flags; |
| import javax.mail.Folder; |
| import javax.mail.Header; |
| import javax.mail.Message; |
| import javax.mail.MessagingException; |
| import javax.mail.Multipart; |
| import javax.mail.Session; |
| import javax.mail.internet.InternetAddress; |
| import javax.mail.internet.InternetHeaders; |
| import javax.mail.internet.MimeMessage; |
| import javax.mail.search.SearchTerm; |
| |
| /** |
| * Forked from JAMES server. |
| */ |
| public class MockMimeMessage extends MimeMessage { |
| |
| private final List m_fromAddresses = new ArrayList(); |
| |
| private Address m_senderAddress; |
| |
| private final List m_toRecepients = new ArrayList(); |
| |
| private final List m_ccRecepients = new ArrayList(); |
| |
| private final List m_bccRecepients = new ArrayList(); |
| |
| private final List m_replyToAddresses = new ArrayList(); |
| |
| private String m_subject; |
| |
| private int m_iMessageNumber; |
| |
| private boolean m_bIsExpunged; |
| |
| private Object m_content; |
| |
| private Date m_sentDate; |
| |
| private String[] m_contentLanguage; |
| |
| private String m_fileName; |
| |
| private DataHandler m_dataHandler; |
| |
| private HashMap m_contentHeaders = new HashMap(); |
| |
| private Flags m_setFlags = new Flags(); |
| |
| private boolean m_doMatch; |
| |
| private int m_size = -1; |
| |
| public MockMimeMessage() throws MessagingException { |
| super((Session) null); |
| } |
| |
| public MockMimeMessage(int messageNumber) throws MessagingException { |
| super((Session) null); |
| m_iMessageNumber = messageNumber; |
| } |
| |
| public MockMimeMessage(MimeMessage mimeMessage) throws MessagingException { |
| super(mimeMessage); // trivial implementation |
| } |
| |
| public Address[] getFrom() throws MessagingException { |
| return (Address[]) m_fromAddresses.toArray(); |
| } |
| |
| public void setFrom(Address address) throws MessagingException { |
| m_fromAddresses.clear(); |
| m_fromAddresses.add(address); |
| } |
| |
| public void setFrom() throws MessagingException { |
| m_fromAddresses.clear(); |
| m_fromAddresses.add(InternetAddress.getLocalAddress(null)); |
| } |
| |
| public void addFrom(Address[] addresses) throws MessagingException { |
| m_fromAddresses.add(addresses); |
| } |
| |
| public Address getSender() throws MessagingException { |
| return m_senderAddress; |
| } |
| |
| public void setSender(Address address) throws MessagingException { |
| m_senderAddress = address; |
| } |
| |
| public Address[] getRecipients(Message.RecipientType recipientType) |
| throws MessagingException { |
| List recipientsList = getRecipientsList(recipientType); |
| List recipientAddresses = new ArrayList(); |
| for (Iterator iterator = recipientsList.iterator(); iterator.hasNext();) { |
| String recipient = (String) iterator.next(); |
| recipientAddresses.add(new InternetAddress(recipient)); |
| } |
| return (Address[]) (recipientAddresses.toArray(new Address[] {})); |
| } |
| |
| private List getRecipientsList(Message.RecipientType recipientType) { |
| if (Message.RecipientType.TO.equals(recipientType)) |
| return m_toRecepients; |
| if (Message.RecipientType.CC.equals(recipientType)) |
| return m_ccRecepients; |
| if (Message.RecipientType.BCC.equals(recipientType)) |
| return m_bccRecepients; |
| return null; |
| } |
| |
| public Address[] getAllRecipients() throws MessagingException { |
| List allRecipients = new ArrayList(); |
| allRecipients.addAll(m_toRecepients); |
| allRecipients.addAll(m_ccRecepients); |
| allRecipients.addAll(m_bccRecepients); |
| return (Address[]) allRecipients.toArray(); |
| } |
| |
| public void setRecipients(Message.RecipientType recipientType, |
| Address[] addresses) throws MessagingException { |
| getRecipientsList(recipientType).addAll(Arrays.asList(addresses)); |
| } |
| |
| public void setRecipients(Message.RecipientType recipientType, |
| String recipient) throws MessagingException { |
| getRecipientsList(recipientType).add(recipient); |
| } |
| |
| public void addRecipients(Message.RecipientType recipientType, |
| Address[] addresses) throws MessagingException { |
| getRecipientsList(recipientType).addAll(Arrays.asList(addresses)); |
| } |
| |
| public void addRecipients(Message.RecipientType recipientType, |
| String recipient) throws MessagingException { |
| getRecipientsList(recipientType).add(recipient); |
| } |
| |
| public Address[] getReplyTo() throws MessagingException { |
| return (Address[]) m_replyToAddresses.toArray(); |
| } |
| |
| public void setReplyTo(Address[] addresses) throws MessagingException { |
| m_replyToAddresses.addAll(Arrays.asList(addresses)); |
| } |
| |
| public String getSubject() throws MessagingException { |
| return m_subject; |
| } |
| |
| public void setSubject(String subject) throws MessagingException { |
| m_subject = subject; |
| } |
| |
| public void setSubject(String subject, String charset) |
| throws MessagingException { |
| if (subject == null) { |
| m_subject = null; |
| return; |
| } |
| try { |
| m_subject = new String(subject.getBytes(charset)); |
| } catch (UnsupportedEncodingException e) { |
| throw new MessagingException("setting subject failed", e); |
| } |
| } |
| |
| public Date getSentDate() throws MessagingException { |
| return m_sentDate; |
| } |
| |
| public void setSentDate(Date date) throws MessagingException { |
| m_sentDate = date; |
| } |
| |
| public Date getReceivedDate() throws MessagingException { |
| return null; // trivial implementation |
| } |
| |
| public int getSize() throws MessagingException { |
| return m_size; // trivial implementation |
| } |
| |
| public int getLineCount() throws MessagingException { |
| return -1; // trivial implementation |
| } |
| |
| public String getContentType() throws MessagingException { |
| return getHeader("Content-Type", null); |
| } |
| |
| public boolean isMimeType(String mimeType) throws MessagingException { |
| return mimeType.startsWith(getContentType()); |
| } |
| |
| public String getDisposition() throws MessagingException { |
| return getHeader("Content-Disposition", null); |
| } |
| |
| public void setDisposition(String disposition) throws MessagingException { |
| setHeader("Content-Disposition", disposition); |
| } |
| |
| public String getEncoding() throws MessagingException { |
| return getHeader("Content-Transfer-Encoding", null); |
| } |
| |
| public String getContentID() throws MessagingException { |
| return getHeader("Content-ID", null); |
| } |
| |
| public void setContentID(String contentID) throws MessagingException { |
| setHeader("Content-ID", contentID); |
| } |
| |
| public String getContentMD5() throws MessagingException { |
| return getHeader("Content-MD5", null); |
| } |
| |
| public void setContentMD5(String value) throws MessagingException { |
| setHeader("Content-MD5", value); |
| } |
| |
| public String getDescription() throws MessagingException { |
| return getHeader("Content-Description", null); |
| } |
| |
| public void setDescription(String description) throws MessagingException { |
| setHeader("Content-Description", description); |
| } |
| |
| public void setDescription(String description, String charset) |
| throws MessagingException { |
| try { |
| setDescription(new String(description.getBytes(charset))); |
| } catch (UnsupportedEncodingException e) { |
| throw new MessagingException("setting description failed", e); |
| } |
| } |
| |
| public String[] getContentLanguage() throws MessagingException { |
| return m_contentLanguage; |
| } |
| |
| public void setContentLanguage(String[] contentLanguage) |
| throws MessagingException { |
| m_contentLanguage = contentLanguage; |
| } |
| |
| public String getMessageID() throws MessagingException { |
| return "ID-" + m_iMessageNumber; // trivial implementation |
| } |
| |
| public String getFileName() throws MessagingException { |
| return m_fileName; |
| } |
| |
| public void setFileName(String fileName) throws MessagingException { |
| m_fileName = fileName; |
| } |
| |
| public InputStream getInputStream() throws IOException, MessagingException { |
| return null; // trivial implementation |
| } |
| |
| protected InputStream getContentStream() throws MessagingException { |
| return null; // trivial implementation |
| } |
| |
| public InputStream getRawInputStream() throws MessagingException { |
| if (m_content instanceof String) { |
| return new ByteArrayInputStream(m_content.toString().getBytes()); |
| } |
| throw new UnsupportedOperationException("Unimplementated method"); |
| } |
| |
| public synchronized DataHandler getDataHandler() throws MessagingException { |
| return m_dataHandler; |
| } |
| |
| public synchronized void setDataHandler(DataHandler dataHandler) |
| throws MessagingException { |
| m_dataHandler = dataHandler; |
| } |
| |
| public Object getContent() throws IOException, MessagingException { |
| return m_content; |
| } |
| |
| public void setContent(Object object, String mimeType) |
| throws MessagingException { |
| m_content = object; // trivial implementation |
| } |
| |
| public void setText(String string) throws MessagingException { |
| setContent(string, "text/plain"); |
| } |
| |
| public void setText(String string, String charset) |
| throws MessagingException { |
| try { |
| setContent(new String(string.getBytes(charset)), "text/plain"); |
| } catch (UnsupportedEncodingException e) { |
| throw new MessagingException("setting text content failed", e); |
| } |
| } |
| |
| public void setContent(Multipart multipart) throws MessagingException { |
| m_content = multipart; |
| } |
| |
| public Message reply(boolean b) throws MessagingException { |
| return new MockMimeMessage(this); // trivial implementation |
| } |
| |
| public void writeTo(OutputStream outputStream) throws IOException, |
| MessagingException { |
| ; // trivial implementation |
| } |
| |
| public void writeTo(OutputStream outputStream, String[] strings) |
| throws IOException, MessagingException { |
| ; // trivial implementation |
| } |
| |
| public String[] getHeader(String name) throws MessagingException { |
| Object value = m_contentHeaders.get(name); |
| if (value == null) |
| return null; |
| if (value instanceof String) { |
| String stringValue = (String) value; |
| return new String[] { stringValue }; |
| } else { |
| Collection values = (Collection) value; |
| return (String[]) values.toArray(new String[values.size()]); |
| } |
| } |
| |
| public String getHeader(String name, String delimiter) |
| throws MessagingException { |
| String[] header = getHeader(name); |
| if (header == null || header.length == 0) |
| return null; |
| return header[0]; |
| } |
| |
| public void setHeader(String name, String value) throws MessagingException { |
| addHeader(name, value); |
| } |
| |
| public void addHeader(String name, String value) throws MessagingException { |
| Object newValue; |
| Object existingValue = m_contentHeaders.get(name); |
| if (existingValue == null) { |
| newValue = value; |
| } else if (existingValue instanceof String) { |
| List values = new ArrayList(); |
| values.add(existingValue); |
| values.add(value); |
| newValue = values; |
| } else { |
| List values = (List) existingValue; |
| values.add(value); |
| newValue = values; |
| } |
| m_contentHeaders.put(name, newValue); |
| } |
| |
| public void removeHeader(String name) throws MessagingException { |
| m_contentHeaders.remove(name); |
| } |
| |
| public Enumeration getAllHeaders() throws MessagingException { |
| final Collection results = new ArrayList(); |
| final Collection entries = m_contentHeaders.entrySet(); |
| for (Iterator it = entries.iterator(); it.hasNext();) { |
| Map.Entry entry = (Map.Entry) it.next(); |
| String name = entry.getKey().toString(); |
| Object value = entry.getValue(); |
| if (value == null) { |
| // ignore |
| } else if (value instanceof Collection) { |
| Collection values = (Collection) value; |
| for (Iterator iterValues = values.iterator(); iterValues |
| .hasNext();) { |
| String stringValue = (String) iterValues.next(); |
| results.add(new Header(name, stringValue)); |
| } |
| } else { |
| results.add(new Header(name, value.toString())); |
| } |
| } |
| return Collections.enumeration(results); |
| } |
| |
| public Enumeration getMatchingHeaders(String[] names) |
| throws MessagingException { |
| ArrayList matchingHeaders = new ArrayList(); |
| for (int i = 0; i < names.length; i++) { |
| String name = names[i]; |
| String value = getHeader(name, null); |
| if (value == null) |
| continue; |
| matchingHeaders.add(value); |
| } |
| return Collections.enumeration(matchingHeaders); |
| } |
| |
| public Enumeration getNonMatchingHeaders(String[] names) |
| throws MessagingException { |
| List existingHeaders = Arrays.asList(names); |
| |
| ArrayList nonMatchingHeaders = new ArrayList(); |
| |
| Iterator iterator = m_contentHeaders.keySet().iterator(); |
| while (iterator.hasNext()) { |
| String name = (String) iterator.next(); |
| if (existingHeaders.contains(name)) |
| continue; |
| String value = getHeader(name, null); |
| if (value == null) |
| continue; |
| nonMatchingHeaders.add(value); |
| } |
| return Collections.enumeration(nonMatchingHeaders); |
| } |
| |
| public void addHeaderLine(String headerLine) throws MessagingException { |
| int separatorIndex = headerLine.indexOf(":"); |
| if (separatorIndex < 0) |
| throw new MessagingException( |
| "header line does not conform to standard"); |
| |
| addHeader(headerLine.substring(0, separatorIndex), headerLine |
| .substring(separatorIndex, headerLine.length())); |
| } |
| |
| public Enumeration getAllHeaderLines() throws MessagingException { |
| return Collections.enumeration(getHeadersAsStrings(m_contentHeaders)); |
| } |
| |
| private ArrayList getHeadersAsStrings(HashMap contentHeaders) { |
| ArrayList headerLines = new ArrayList(); |
| Iterator iterator = contentHeaders.keySet().iterator(); |
| while (iterator.hasNext()) { |
| String key = (String) iterator.next(); |
| String value = (String) contentHeaders.get(key); |
| headerLines.add(key + ":" + value); |
| } |
| return headerLines; |
| } |
| |
| public Enumeration getMatchingHeaderLines(String[] names) |
| throws MessagingException { |
| ArrayList matchingHeaders = new ArrayList(); |
| for (int i = 0; i < names.length; i++) { |
| String name = names[i]; |
| String value = getHeader(name, null); |
| if (value == null) |
| continue; |
| matchingHeaders.add(name + ":" + value); |
| } |
| return Collections.enumeration(matchingHeaders); |
| } |
| |
| public Enumeration getNonMatchingHeaderLines(String[] names) |
| throws MessagingException { |
| List existingHeaders = names != null ? Arrays.asList(names) : null; |
| |
| ArrayList nonMatchingHeaders = new ArrayList(); |
| |
| Iterator iterator = m_contentHeaders.keySet().iterator(); |
| while (iterator.hasNext()) { |
| String name = (String) iterator.next(); |
| if (existingHeaders != null && existingHeaders.contains(name)) |
| continue; |
| String value = getHeader(name, null); |
| if (value == null) |
| continue; |
| nonMatchingHeaders.add(name + ":" + value); |
| } |
| return Collections.enumeration(nonMatchingHeaders); |
| } |
| |
| public synchronized Flags getFlags() throws MessagingException { |
| return new Flags(m_setFlags); |
| } |
| |
| public synchronized boolean isSet(Flags.Flag flag) |
| throws MessagingException { |
| return m_setFlags.contains(flag); |
| } |
| |
| public synchronized void setFlags(Flags flags, boolean set) |
| throws MessagingException { |
| if (set) |
| m_setFlags.add(flags); |
| else |
| m_setFlags.remove(flags); |
| } |
| |
| public void saveChanges() throws MessagingException { |
| ; // trivial implementation |
| } |
| |
| protected void updateHeaders() throws MessagingException { |
| ; // trivial implementation |
| } |
| |
| protected InternetHeaders createInternetHeaders(InputStream inputStream) |
| throws MessagingException { |
| return new InternetHeaders(); |
| } |
| |
| public void setRecipient(Message.RecipientType recipientType, |
| Address address) throws MessagingException { |
| setRecipients(recipientType, new Address[] { address }); |
| } |
| |
| public void addRecipient(Message.RecipientType recipientType, |
| Address address) throws MessagingException { |
| setRecipients(recipientType, new Address[] { address }); |
| } |
| |
| public void setFlag(Flags.Flag flag, boolean set) throws MessagingException { |
| if (set) |
| m_setFlags.add(flag); |
| else |
| m_setFlags.remove(flag); |
| } |
| |
| public int getMessageNumber() { |
| return m_iMessageNumber; |
| } |
| |
| protected void setMessageNumber(int i) { |
| m_iMessageNumber = i; |
| } |
| |
| public Folder getFolder() { |
| return null; |
| } |
| |
| public boolean isExpunged() { |
| return m_bIsExpunged; |
| } |
| |
| protected void setExpunged(boolean b) { |
| m_bIsExpunged = b; |
| } |
| |
| public void setShouldMatch(boolean doMatch) { |
| m_doMatch = doMatch; |
| } |
| |
| public boolean match(SearchTerm searchTerm) throws MessagingException { |
| return m_doMatch; |
| } |
| |
| public void setSize(int size) { |
| this.m_size = size; |
| } |
| } |