Mercurial > hg > release > thermostat-0.11
changeset 126:162224d328b3
Merge
author | Roman Kennke <rkennke@redhat.com> |
---|---|
date | Tue, 20 Mar 2012 23:51:28 +0100 |
parents | 25688634a1d6 (current diff) a5c415a6100d (diff) |
children | 9ae036f42ea8 |
files | |
diffstat | 4 files changed, 240 insertions(+), 6 deletions(-) [+] |
line wrap: on
line diff
--- a/common/src/main/java/com/redhat/thermostat/common/storage/Key.java Tue Mar 20 23:49:39 2012 +0100 +++ b/common/src/main/java/com/redhat/thermostat/common/storage/Key.java Tue Mar 20 23:51:28 2012 +0100 @@ -49,6 +49,9 @@ private boolean isPartialCategoryKey; public Key(String name, boolean isPartialCategoryKey) { + if (name == null || name.length() == 0) { + throw new IllegalArgumentException("A Key must have a non-null name of length >= 1."); + } this.name = name; this.isPartialCategoryKey = isPartialCategoryKey; }
--- a/common/src/test/java/com/redhat/thermostat/common/storage/ChunkTest.java Tue Mar 20 23:49:39 2012 +0100 +++ b/common/src/test/java/com/redhat/thermostat/common/storage/ChunkTest.java Tue Mar 20 23:51:28 2012 +0100 @@ -36,7 +36,12 @@ package com.redhat.thermostat.common.storage; -import static org.junit.Assert.*; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; import org.junit.Test; @@ -47,20 +52,96 @@ private static final Key<String> key3 = new Key<>("key3", false); private static final Key<String> key4 = new Key<>("key4", false); private static final Key<String> key5 = new Key<>("key5", false); + private static final Key<Integer> key6 = new Key<>("key6", false); + private static final Key<Object> key7 = new Key<>("key7", false); + + private static final String value1 = "test1"; + private static final String value2 = "test2"; + private static final String value3 = "test3"; + private static final String value4 = "test4"; + private static final String value5 = "test5"; + private static final int value6 = 12345; + private static final Object value7 = "test7"; private static final Category testCategory = new Category("ChunkTest", key1, key2, key3, key4, key5); + @Test + public void verifyGetCategoryNotNull() { + Chunk chunk = new Chunk(testCategory, false); + Category cat = chunk.getCategory(); + assertNotNull(cat); + } + + @Test + public void verifyGetCategoryReturnsCorrectCategory() { + Chunk chunk = new Chunk(testCategory, false); + Category cat = chunk.getCategory(); + assertEquals(cat, testCategory); + } + + @Test + public void verifyGetReplaceReturnsCorrectValue() { + Chunk chunk = new Chunk(testCategory, false); + boolean replace = chunk.getReplace(); + assertFalse(replace); + chunk = new Chunk(testCategory, true); + replace = chunk.getReplace(); + assertTrue(replace); + } + + @Test + public void verifyPutActuallyPuts() { + Chunk chunk = new Chunk(testCategory, false); + chunk.put(key1, value1); + int pieces = chunk.getKeys().size(); + assertEquals(pieces, 1); + } + + @Test + public void verifyPutPutsCorrectly() { + Chunk chunk = new Chunk(testCategory, false); + chunk.put(key1, value1); + String value = chunk.get(key1); + assertEquals(value, value1); + } + + @Test + public void verifyPutAcceptsVariousTypes() { + Chunk chunk = new Chunk(testCategory, false); + chunk.put(key1, value1); + chunk.put(key5, value5); + chunk.put(key6, value6); + chunk.put(key7, value7); + int pieces = chunk.getKeys().size(); + assertEquals(pieces, 4); + } @Test public void verifyEntriesAreKeptInOrder() { Chunk chunk = new Chunk(testCategory, false); - chunk.put(key5, "test1"); - chunk.put(key4, "test2"); - chunk.put(key3, "test3"); - chunk.put(key2, "test4"); - chunk.put(key1, "test5"); + chunk.put(key5, value5); + chunk.put(key4, value4); + chunk.put(key3, value3); + chunk.put(key2, value2); + chunk.put(key1, value1); assertArrayEquals(new Key<?>[]{key5, key4, key3, key2, key1}, chunk.getKeys().toArray()); } + @Test + public void verifyGetNotNull() { + Chunk chunk = new Chunk(testCategory, false); + chunk.put(key1, value1); + String value = chunk.get(key1); + assertNotNull(value); + } + + @Test + public void verifyGetNullWhenExpected() { + Chunk chunk = new Chunk(testCategory, false); + chunk.put(key1, value1); + String value = chunk.get(key2); + assertNull(value); + } + }
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/src/test/java/com/redhat/thermostat/common/storage/KeyTest.java Tue Mar 20 23:51:28 2012 +0100 @@ -0,0 +1,133 @@ +/* + * Copyright 2012 Red Hat, Inc. + * + * This file is part of Thermostat. + * + * Thermostat is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published + * by the Free Software Foundation; either version 2, or (at your + * option) any later version. + * + * Thermostat is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with Thermostat; see the file COPYING. If not see + * <http://www.gnu.org/licenses/>. + * + * Linking this code with other modules is making a combined work + * based on this code. Thus, the terms and conditions of the GNU + * General Public License cover the whole combination. + * + * As a special exception, the copyright holders of this code give + * you permission to link this code with independent modules to + * produce an executable, regardless of the license terms of these + * independent modules, and to copy and distribute the resulting + * executable under terms of your choice, provided that you also + * meet, for each linked independent module, the terms and conditions + * of the license of that module. An independent module is a module + * which is not derived from or based on this code. If you modify + * this code, you may extend this exception to your version of the + * library, but you are not obligated to do so. If you do not wish + * to do so, delete this exception statement from your version. + */ + +package com.redhat.thermostat.common.storage; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.not; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +import org.junit.Test; + +public class KeyTest { + private static final String name1 = "key1"; + private static final String name2 = "key2"; + private static final String name3 = "key3"; + + private static final Key<String> key1 = new Key<>(name1, true); + private static final Key<String> key2 = new Key<>(name2, true); + private static final Key<String> key3 = new Key<>(name3, false); + private static final Key<String> key4 = new Key<>(name1, false); + private static final Key<String> key5 = new Key<>(name1, true); + + @Test + public void verifyConstructorResultsInExpectedValues() { + Key<String> key = new Key<>(name1, true); + assertEquals(key.getName(), name1); + assertTrue(key.isPartialCategoryKey()); + key = new Key<>(name2, false); + assertEquals(key.getName(), name2); + assertFalse(key.isPartialCategoryKey()); + } + + @Test (expected=IllegalArgumentException.class) + public void verifyConstructorThrowsExceptionOnNullName() { + @SuppressWarnings("unused") + Key<String> key = new Key<>(null, true); + } + + @Test (expected=IllegalArgumentException.class) + public void verifyConstructorThrowsExceptionZeroLengthName() { + @SuppressWarnings("unused") + Key<String> key = new Key<>("", true); + } + + @Test + public void verifyGetNameNotNull() { + String name = key1.getName(); + assertNotNull(name); + } + + @Test + public void verifyGetNameReturnsCorrectName() { + String name = key1.getName(); + assertEquals(name, name1); + name = key2.getName(); + assertEquals(name, name2); + } + + @Test + public void verifyIsPartialCategoryKeyReturnsCorrectValue() { + boolean value = key1.isPartialCategoryKey(); + assertTrue(value); + value = key3.isPartialCategoryKey(); + assertFalse(value); + } + + @Test + public void verifyEqualsReturnsCorrectValue() { + assertThat(key1, not(equalTo(key2))); + assertThat(key1, not(equalTo(key3))); + assertThat(key1, not(equalTo(key4))); + assertThat(key1, equalTo(key5)); + } + + @Test + public void verifyHashCodeReturnsValidCode() { + int key1hash1 = key1.hashCode(); + int key1hash2 = key1.hashCode(); + assertEquals(key1hash1, key1hash2); + int key5hash1 = key5.hashCode(); + assertEquals(key1hash1, key5hash1); + } + + @Test + public void toStringNotNull() { + String string1 = key1.toString(); + assertNotNull(string1); + } + + @Test + public void toStringReturnsExpectedString() { + String string1 = key1.toString(); + assertEquals(string1, "Key: key1"); + } +}
--- a/common/src/test/java/com/redhat/thermostat/common/storage/MongoStorageTest.java Tue Mar 20 23:49:39 2012 +0100 +++ b/common/src/test/java/com/redhat/thermostat/common/storage/MongoStorageTest.java Tue Mar 20 23:51:28 2012 +0100 @@ -204,10 +204,27 @@ } @Test + public void verifyFindReturnsCorrectChunk() { + + // TODO find a way to test this that isn't just testing mock and converters + Chunk query = new Chunk(testCategory, false); + // Because we mock the DBCollection, the contents of this query don't actually determine the result. + query.put(key5, "test1"); + + Chunk result = storage.find(query); + + assertNotNull(result); + assertArrayEquals(new Key<?>[]{key1, key2}, result.getKeys().toArray()); + assertEquals("test1", result.get(key1)); + assertEquals("test2", result.get(key2)); + } + + @Test public void verifyFindAllReturnsCorrectCursor() { // TODO find a way to test this that isn't just testing MongoCursor Chunk query = new Chunk(testCategory, false); + // Because we mock the DBCollection, the contents of this query don't actually determine the result. query.put(key5, "test1"); Cursor cursor = storage.findAll(query);