org.apache.ace.log/test/org/apache/ace/log/server/servlet/LogServletTest.java - ace - Git at Google

 /*
  * 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.ace.log.server.servlet;

 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.Dictionary;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import javax.servlet.ReadListener;
 import javax.servlet.ServletInputStream;
 import javax.servlet.ServletOutputStream;
 import javax.servlet.WriteListener;

 import org.apache.ace.feedback.Descriptor;
 import org.apache.ace.feedback.Event;
 import org.apache.ace.log.server.store.LogStore;
 import org.apache.ace.range.SortedRangeSet;
 import org.apache.ace.test.utils.TestUtils;
 import org.osgi.service.log.LogService;
 import org.testng.annotations.AfterMethod;
 import org.testng.annotations.BeforeMethod;
 import org.testng.annotations.Test;

 public class LogServletTest {

     private LogServlet m_logServlet;
     private Descriptor m_range = new Descriptor("tID", 123, new SortedRangeSet("1-3"));
     private Event m_event1 = new Event("tID", 123, 1, 888888, 1);
     private Event m_event2 = new Event("tID", 123, 2, 888888, 2);
     private MockLogStore m_mockStore;

     @BeforeMethod(alwaysRun = true)
     protected void setUp() throws Exception {
         m_logServlet = new LogServlet("test");
         TestUtils.configureObject(m_logServlet, LogService.class);
         m_mockStore = new MockLogStore();
         TestUtils.configureObject(m_logServlet, LogStore.class, m_mockStore);
     }

     @AfterMethod(alwaysRun = true)
     protected void tearDown() throws Exception {
     }

     @Test()
     public void queryLog() throws Exception {
         MockServletOutputStream output = new MockServletOutputStream();
         boolean result = m_logServlet.handleQuery(m_range.getTargetID(), String.valueOf(m_range.getStoreID()), null, output);
         assert result;
         assert m_range.toRepresentation().equals(output.m_text);
         output.m_text = "";
         result = m_logServlet.handleQuery(null, null, null, output);
         assert result;
         assert (m_range.toRepresentation() + "\n").equals(output.m_text);
     }

     @Test()
     public void queryLogWithTargetFilter() throws Exception {
         MockServletOutputStream output = new MockServletOutputStream();
         boolean result = m_logServlet.handleQuery(m_range.getTargetID(), null, null, output);
         assert result;
         assert m_range.toRepresentation().equals(output.m_text.trim());
         output.m_text = "";
         result = m_logServlet.handleQuery(null, null, null, output);
         assert result;
         assert (m_range.toRepresentation() + "\n").equals(output.m_text);
     }

     @Test()
     public void receiveLowestID() throws Exception {
         // no lowest ID set
         MockServletOutputStream output = new MockServletOutputStream();
         boolean result = m_logServlet.handleReceiveIDs(m_range.getTargetID(), String.valueOf(m_range.getStoreID()), null, output);
         assert result;
         String expected = "";
         String actual = output.m_text;
         assert expected.equals(actual) : "We expected '" + expected + "', but received '" + actual + "'";

         // set lowest ID
         m_mockStore.setLowestID(m_range.getTargetID(), m_range.getStoreID(), 5);
         output = new MockServletOutputStream();
         result = m_logServlet.handleReceiveIDs(m_range.getTargetID(), String.valueOf(m_range.getStoreID()), null, output);
         assert result;
         expected = m_range.getTargetID() + "," + m_range.getStoreID() + ",5\n";
         actual = output.m_text;
         assert expected.equals(actual) : "We expected '" + expected + "', but received '" + actual + "'";
     }

     @Test()
     public void sendLowestID() throws Exception {
         MockServletInputStream input = new MockServletInputStream();
         String expected = m_range.getTargetID() + "," + m_range.getStoreID() + ",9\n";
         input.setBytes(expected.getBytes());
         m_logServlet.handleSendIDs(input);
         long lowestID = m_mockStore.getLowestID(m_range.getTargetID(), m_range.getStoreID());
         assert 9 == lowestID : "Expected lowest ID to be 9, but got: " + lowestID;
     }

     @Test()
     public void receiveLog() throws Exception {
         MockServletOutputStream output = new MockServletOutputStream();
         boolean result = m_logServlet.handleReceive(m_range.getTargetID(), String.valueOf(m_range.getStoreID()), "1", null, output);
         assert result;
         String expected = m_event1.toRepresentation() + "\n";
         String actual = output.m_text;
         assert expected.equals(actual) : "We expected '" + expected + "', but received '" + actual + "'";

         output = new MockServletOutputStream();
         result = m_logServlet.handleReceive(m_range.getTargetID(), String.valueOf(m_range.getStoreID()), null, null, output);
         assert result;
         expected = m_event1.toRepresentation() + "\n" + m_event2.toRepresentation() + "\n";
         actual = output.m_text;
         assert expected.equals(actual) : "We expected '" + expected + "', but received '" + actual + "'";
         ;
     }

     @Test()
     public void sendLog() throws Exception {
         MockServletInputStream input = new MockServletInputStream();
         String expected = m_event1.toRepresentation() + "\n" + m_event2.toRepresentation() + "\n";
         input.setBytes(expected.getBytes());
         m_logServlet.handleSend(input);

         String actual = "";
         for (Iterator<Event> i = m_mockStore.m_events.iterator(); i.hasNext();) {
             Event event = i.next();
             actual = actual + event.toRepresentation() + "\n";
         }
         assert expected.equals(actual);
     }

     private static class Tuple {
         private final String m_targetID;
         private final long m_logID;

         public Tuple(String targetID, long logID) {
             if (targetID == null) {
                 throw new IllegalArgumentException("TargetID cannot be null");
             }
             m_targetID = targetID;
             m_logID = logID;
         }

         public String getTargetID() {
             return m_targetID;
         }

         public long getLogID() {
             return m_logID;
         }

         @Override
         public int hashCode() {
             final int prime = 31;
             int result = 1;
             result = prime * result + (int) (m_logID ^ (m_logID >>> 32));
             result = prime * result + m_targetID.hashCode();
             return result;
         }

         @Override
         public boolean equals(Object obj) {
             if (this == obj) {
                 return true;
             }
             if (obj == null) {
                 return false;
             }
             if (getClass() != obj.getClass()) {
                 return false;
             }
             Tuple other = (Tuple) obj;
             return (m_logID == other.getLogID() && m_targetID.equals(other.getTargetID()));
         }
     }

     private class MockLogStore implements LogStore {
         public List<Event> m_events = new ArrayList<>();

         public List<Event> get(Descriptor range) {
             List<Event> events = new ArrayList<>();
             if (range.getRangeSet().contains(1)) {
                 events.add(m_event1);
             }
             if (range.getRangeSet().contains(2)) {
                 events.add(m_event2);
             }
             return events;
         }

         public List<Descriptor> getDescriptors(String targetID) {
             List<Descriptor> ranges = new ArrayList<>();
             ranges.add(m_range);
             return ranges;
         }

         public List<Descriptor> getDescriptors() {
             List<Descriptor> ranges = new ArrayList<>();
             ranges.add(m_range);
             return ranges;
         }

         public Descriptor getDescriptor(String targetID, long logID) throws IOException {
             return m_range;
         }

         public void put(List<Event> events) throws IOException {
             m_events = events;
         }

         public void clean() throws IOException {
             throw new UnsupportedOperationException("not implemented");
         }

         @Override
         public Event put(String targetID, int type, Dictionary props) throws IOException {
             throw new UnsupportedOperationException("not implemented");
         }

         private Map<Tuple, Long> m_lowestIDs = new HashMap<>();

         @Override
         public void setLowestID(String targetID, long logID, long lowestID) throws IOException {
             m_lowestIDs.put(new Tuple(targetID, logID), lowestID);
         }

         @Override
         public long getLowestID(String targetID, long logID) throws IOException {
             Long result = m_lowestIDs.get(new Tuple(targetID, logID));
             return result == null ? 0 : result.longValue();
         }
     }

     private class MockServletOutputStream extends ServletOutputStream {
         public String m_text = "";

         @Override
         public void print(String s) throws IOException {
             m_text = m_text.concat(s);
         }

         @Override
         public void write(int arg0) throws IOException {
         }

         @Override
         public boolean isReady() {
             return true;
         }

         @Override
         public void setWriteListener(WriteListener l) {
             // nop
         }
     }

     private class MockServletInputStream extends ServletInputStream {
         private int i = 0;
         private byte[] m_bytes;

         @Override
         public int read() throws IOException {
             int result = -1;
             if (i < m_bytes.length) {
                 result = m_bytes[i];
                 i++;
             }
             return result;
         }

         public void setBytes(byte[] bytes) {
             m_bytes = bytes;
         }

         @Override
         public boolean isFinished() {
             return i >= m_bytes.length;
         }

         @Override
         public boolean isReady() {
             return true;
         }

         @Override
         public void setReadListener(ReadListener l) {
             // nop
         }
     }
 }
	/*
	* 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.ace.log.server.servlet;

	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.Dictionary;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	import javax.servlet.ReadListener;
	import javax.servlet.ServletInputStream;
	import javax.servlet.ServletOutputStream;
	import javax.servlet.WriteListener;

	import org.apache.ace.feedback.Descriptor;
	import org.apache.ace.feedback.Event;
	import org.apache.ace.log.server.store.LogStore;
	import org.apache.ace.range.SortedRangeSet;
	import org.apache.ace.test.utils.TestUtils;
	import org.osgi.service.log.LogService;
	import org.testng.annotations.AfterMethod;
	import org.testng.annotations.BeforeMethod;
	import org.testng.annotations.Test;

	public class LogServletTest {

	private LogServlet m_logServlet;
	private Descriptor m_range = new Descriptor("tID", 123, new SortedRangeSet("1-3"));
	private Event m_event1 = new Event("tID", 123, 1, 888888, 1);
	private Event m_event2 = new Event("tID", 123, 2, 888888, 2);
	private MockLogStore m_mockStore;

	@BeforeMethod(alwaysRun = true)
	protected void setUp() throws Exception {
	m_logServlet = new LogServlet("test");
	TestUtils.configureObject(m_logServlet, LogService.class);
	m_mockStore = new MockLogStore();
	TestUtils.configureObject(m_logServlet, LogStore.class, m_mockStore);
	}

	@AfterMethod(alwaysRun = true)
	protected void tearDown() throws Exception {
	}

	@Test()
	public void queryLog() throws Exception {
	MockServletOutputStream output = new MockServletOutputStream();
	boolean result = m_logServlet.handleQuery(m_range.getTargetID(), String.valueOf(m_range.getStoreID()), null, output);
	assert result;
	assert m_range.toRepresentation().equals(output.m_text);
	output.m_text = "";
	result = m_logServlet.handleQuery(null, null, null, output);
	assert result;
	assert (m_range.toRepresentation() + "\n").equals(output.m_text);
	}

	@Test()
	public void queryLogWithTargetFilter() throws Exception {
	MockServletOutputStream output = new MockServletOutputStream();
	boolean result = m_logServlet.handleQuery(m_range.getTargetID(), null, null, output);
	assert result;
	assert m_range.toRepresentation().equals(output.m_text.trim());
	output.m_text = "";
	result = m_logServlet.handleQuery(null, null, null, output);
	assert result;
	assert (m_range.toRepresentation() + "\n").equals(output.m_text);
	}

	@Test()
	public void receiveLowestID() throws Exception {
	// no lowest ID set
	MockServletOutputStream output = new MockServletOutputStream();
	boolean result = m_logServlet.handleReceiveIDs(m_range.getTargetID(), String.valueOf(m_range.getStoreID()), null, output);
	assert result;
	String expected = "";
	String actual = output.m_text;
	assert expected.equals(actual) : "We expected '" + expected + "', but received '" + actual + "'";

	// set lowest ID
	m_mockStore.setLowestID(m_range.getTargetID(), m_range.getStoreID(), 5);
	output = new MockServletOutputStream();
	result = m_logServlet.handleReceiveIDs(m_range.getTargetID(), String.valueOf(m_range.getStoreID()), null, output);
	assert result;
	expected = m_range.getTargetID() + "," + m_range.getStoreID() + ",5\n";
	actual = output.m_text;
	assert expected.equals(actual) : "We expected '" + expected + "', but received '" + actual + "'";
	}

	@Test()
	public void sendLowestID() throws Exception {
	MockServletInputStream input = new MockServletInputStream();
	String expected = m_range.getTargetID() + "," + m_range.getStoreID() + ",9\n";
	input.setBytes(expected.getBytes());
	m_logServlet.handleSendIDs(input);
	long lowestID = m_mockStore.getLowestID(m_range.getTargetID(), m_range.getStoreID());
	assert 9 == lowestID : "Expected lowest ID to be 9, but got: " + lowestID;
	}

	@Test()
	public void receiveLog() throws Exception {
	MockServletOutputStream output = new MockServletOutputStream();
	boolean result = m_logServlet.handleReceive(m_range.getTargetID(), String.valueOf(m_range.getStoreID()), "1", null, output);
	assert result;
	String expected = m_event1.toRepresentation() + "\n";
	String actual = output.m_text;
	assert expected.equals(actual) : "We expected '" + expected + "', but received '" + actual + "'";

	output = new MockServletOutputStream();
	result = m_logServlet.handleReceive(m_range.getTargetID(), String.valueOf(m_range.getStoreID()), null, null, output);
	assert result;
	expected = m_event1.toRepresentation() + "\n" + m_event2.toRepresentation() + "\n";
	actual = output.m_text;
	assert expected.equals(actual) : "We expected '" + expected + "', but received '" + actual + "'";
	;
	}

	@Test()
	public void sendLog() throws Exception {
	MockServletInputStream input = new MockServletInputStream();
	String expected = m_event1.toRepresentation() + "\n" + m_event2.toRepresentation() + "\n";
	input.setBytes(expected.getBytes());
	m_logServlet.handleSend(input);

	String actual = "";
	for (Iterator<Event> i = m_mockStore.m_events.iterator(); i.hasNext();) {
	Event event = i.next();
	actual = actual + event.toRepresentation() + "\n";
	}
	assert expected.equals(actual);
	}

	private static class Tuple {
	private final String m_targetID;
	private final long m_logID;

	public Tuple(String targetID, long logID) {
	if (targetID == null) {
	throw new IllegalArgumentException("TargetID cannot be null");
	}
	m_targetID = targetID;
	m_logID = logID;
	}

	public String getTargetID() {
	return m_targetID;
	}

	public long getLogID() {
	return m_logID;
	}

	@Override
	public int hashCode() {
	final int prime = 31;
	int result = 1;
	result = prime * result + (int) (m_logID ^ (m_logID >>> 32));
	result = prime * result + m_targetID.hashCode();
	return result;
	}

	@Override
	public boolean equals(Object obj) {
	if (this == obj) {
	return true;
	}
	if (obj == null) {
	return false;
	}
	if (getClass() != obj.getClass()) {
	return false;
	}
	Tuple other = (Tuple) obj;
	return (m_logID == other.getLogID() && m_targetID.equals(other.getTargetID()));
	}
	}

	private class MockLogStore implements LogStore {
	public List<Event> m_events = new ArrayList<>();

	public List<Event> get(Descriptor range) {
	List<Event> events = new ArrayList<>();
	if (range.getRangeSet().contains(1)) {
	events.add(m_event1);
	}
	if (range.getRangeSet().contains(2)) {
	events.add(m_event2);
	}
	return events;
	}

	public List<Descriptor> getDescriptors(String targetID) {
	List<Descriptor> ranges = new ArrayList<>();
	ranges.add(m_range);
	return ranges;
	}

	public List<Descriptor> getDescriptors() {
	List<Descriptor> ranges = new ArrayList<>();
	ranges.add(m_range);
	return ranges;
	}

	public Descriptor getDescriptor(String targetID, long logID) throws IOException {
	return m_range;
	}

	public void put(List<Event> events) throws IOException {
	m_events = events;
	}

	public void clean() throws IOException {
	throw new UnsupportedOperationException("not implemented");
	}

	@Override
	public Event put(String targetID, int type, Dictionary props) throws IOException {
	throw new UnsupportedOperationException("not implemented");
	}

	private Map<Tuple, Long> m_lowestIDs = new HashMap<>();

	@Override
	public void setLowestID(String targetID, long logID, long lowestID) throws IOException {
	m_lowestIDs.put(new Tuple(targetID, logID), lowestID);
	}

	@Override
	public long getLowestID(String targetID, long logID) throws IOException {
	Long result = m_lowestIDs.get(new Tuple(targetID, logID));
	return result == null ? 0 : result.longValue();
	}
	}

	private class MockServletOutputStream extends ServletOutputStream {
	public String m_text = "";

	@Override
	public void print(String s) throws IOException {
	m_text = m_text.concat(s);
	}

	@Override
	public void write(int arg0) throws IOException {
	}

	@Override
	public boolean isReady() {
	return true;
	}

	@Override
	public void setWriteListener(WriteListener l) {
	// nop
	}
	}

	private class MockServletInputStream extends ServletInputStream {
	private int i = 0;
	private byte[] m_bytes;

	@Override
	public int read() throws IOException {
	int result = -1;
	if (i < m_bytes.length) {
	result = m_bytes[i];
	i++;
	}
	return result;
	}

	public void setBytes(byte[] bytes) {
	m_bytes = bytes;
	}

	@Override
	public boolean isFinished() {
	return i >= m_bytes.length;
	}

	@Override
	public boolean isReady() {
	return true;
	}

	@Override
	public void setReadListener(ReadListener l) {
	// nop
	}
	}
	}