Skip to content

Commit cc65ae2

Browse files
fractalwrenchfractalwrench
authored
Merge pull request #76 from bugsnag/add-filtered-map-test
Add filtering to entrySet and values in FilteredMap
2 parents ff4127e + 3563546 commit cc65ae2

2 files changed

Lines changed: 176 additions & 2 deletions

File tree

‎src/main/java/com/bugsnag/util/FilteredMap.java‎

Lines changed: 16 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -3,6 +3,7 @@
33

44
import java.util.ArrayList;
55
import java.util.Collection;
6+
import java.util.HashSet;
67
import java.util.Map;
78
import java.util.Set;
89

@@ -74,12 +75,25 @@ public Set<String> keySet() {
7475

7576
@Override
7677
public Collection<Object> values() {
77-
return map.values();
78+
Collection<Object> objects = new ArrayList<Object>();
79+
80+
for (Entry<String, Object> entry : entrySet()) {
81+
objects.add(entry.getValue());
82+
}
83+
return objects;
7884
}
7985

8086
@Override
8187
public Set<Entry<String, Object>> entrySet() {
82-
return map.entrySet();
88+
Set<Entry<String, Object>> entries = map.entrySet();
89+
Set<Entry<String, Object>> copy = new HashSet<Entry<String, Object>>();
90+
copy.addAll(entries);
91+
92+
for (Entry<String, Object> entry : copy) {
93+
String key = entry.getKey();
94+
entry.setValue(transformEntry(key, entry.getValue()));
95+
}
96+
return copy;
8397
}
8498

8599
private Object transformEntry(Object key, Object value) {

‎src/test/java/com/bugsnag/util/FilteredMapTest.java‎

Lines changed: 160 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,160 @@
1+
package com.bugsnag.util;
2+
3+
import static org.junit.Assert.assertEquals;
4+
import static org.junit.Assert.assertFalse;
5+
import static org.junit.Assert.assertTrue;
6+
7+
import org.junit.Before;
8+
import org.junit.Test;
9+
10+
import java.util.Collection;
11+
import java.util.Collections;
12+
import java.util.HashMap;
13+
import java.util.Map;
14+
import java.util.Set;
15+
16+
public class FilteredMapTest {
17+
18+
private static final String KEY_UNFILTERED = "unfiltered";
19+
private static final String KEY_FILTERED = "auth";
20+
private static final String KEY_NESTED = "nested";
21+
private static final String VAL_UNFILTERED = "Foo";
22+
private static final String VAL_FILTERED = "Bar";
23+
private static final String PLACEHOLDER_FILTERED = "[FILTERED]";
24+
25+
private Map<String, Object> filteredMap;
26+
27+
/**
28+
* Creates a map with filtered, unfiltered, and nested values
29+
* @throws Exception an exception
30+
*/
31+
@Before
32+
public void setUp() throws Exception {
33+
HashMap<String, Object> map = new HashMap<String, Object>();
34+
map.put(KEY_UNFILTERED, VAL_UNFILTERED);
35+
map.put(KEY_FILTERED, VAL_FILTERED);
36+
37+
HashMap<String, Object> nestedMap = new HashMap<String, Object>();
38+
nestedMap.put(KEY_UNFILTERED, VAL_UNFILTERED);
39+
nestedMap.put(KEY_FILTERED, VAL_FILTERED);
40+
map.put(KEY_NESTED, nestedMap);
41+
42+
this.filteredMap = new FilteredMap(map, Collections.singleton(KEY_FILTERED));
43+
}
44+
45+
@Test
46+
public void testSize() {
47+
assertEquals(3, filteredMap.size());
48+
}
49+
50+
@Test
51+
public void testIsEmpty() throws Exception {
52+
assertFalse(filteredMap.isEmpty());
53+
Map<String, Object> map = Collections.emptyMap();
54+
FilteredMap emptyMap = new FilteredMap(map, Collections.<String>emptyList());
55+
assertTrue(emptyMap.isEmpty());
56+
}
57+
58+
@Test
59+
public void testClear() throws Exception {
60+
assertEquals(3, filteredMap.size());
61+
filteredMap.clear();
62+
assertTrue(filteredMap.isEmpty());
63+
}
64+
65+
@Test
66+
public void testContainsKey() throws Exception {
67+
assertTrue(filteredMap.containsKey(KEY_FILTERED));
68+
assertTrue(filteredMap.containsKey(KEY_UNFILTERED));
69+
assertTrue(filteredMap.containsKey(KEY_NESTED));
70+
assertFalse(filteredMap.containsKey("fake"));
71+
}
72+
73+
@Test
74+
public void testRemove() throws Exception {
75+
HashMap<String, Object> map = new HashMap<String, Object>();
76+
map.put(KEY_UNFILTERED, VAL_UNFILTERED);
77+
map.put(KEY_FILTERED, VAL_FILTERED);
78+
79+
HashMap<String, Object> emptyMap = new HashMap<String, Object>();
80+
Set<String> filters = Collections.singleton(KEY_FILTERED);
81+
Map<String, Object> removeMap = new FilteredMap(emptyMap, filters);
82+
removeMap.putAll(map);
83+
84+
assertEquals(2, removeMap.size());
85+
removeMap.remove(KEY_FILTERED);
86+
assertEquals(1, removeMap.size());
87+
removeMap.remove(KEY_UNFILTERED);
88+
assertEquals(0, removeMap.size());
89+
}
90+
91+
@Test
92+
public void testGet() throws Exception {
93+
assertEquals(PLACEHOLDER_FILTERED, filteredMap.get(KEY_FILTERED));
94+
assertEquals(VAL_UNFILTERED, filteredMap.get(KEY_UNFILTERED));
95+
96+
Object actual = filteredMap.get(KEY_NESTED);
97+
assertTrue(actual instanceof FilteredMap);
98+
99+
Map<String, Object> nestedMap = (Map<String, Object>) actual;
100+
assertEquals(VAL_UNFILTERED, nestedMap.get(KEY_UNFILTERED));
101+
assertEquals(PLACEHOLDER_FILTERED, nestedMap.get(KEY_FILTERED));
102+
}
103+
104+
@Test
105+
public void testKeySet() throws Exception {
106+
Set<String> keySet = filteredMap.keySet();
107+
assertEquals(3, keySet.size());
108+
assertTrue(keySet.contains(KEY_FILTERED));
109+
assertTrue(keySet.contains(KEY_UNFILTERED));
110+
assertTrue(keySet.contains(KEY_NESTED));
111+
}
112+
113+
@Test
114+
public void testValues() throws Exception {
115+
Collection<Object> values = filteredMap.values();
116+
assertEquals(3, values.size());
117+
assertTrue(values.contains(VAL_UNFILTERED));
118+
assertTrue(values.contains(PLACEHOLDER_FILTERED));
119+
120+
values.remove(PLACEHOLDER_FILTERED);
121+
values.remove(VAL_UNFILTERED);
122+
123+
Object nestedObj = values.toArray(new Object[1])[0];
124+
assertTrue(nestedObj instanceof FilteredMap);
125+
Map<String, Object> nestedMap = (Map<String, Object>) nestedObj;
126+
values = nestedMap.values();
127+
128+
assertEquals(2, values.size());
129+
assertTrue(values.contains(VAL_UNFILTERED));
130+
assertTrue(values.contains(PLACEHOLDER_FILTERED));
131+
}
132+
133+
@Test
134+
public void testEntrySet() throws Exception {
135+
Set<Map.Entry<String, Object>> entries = filteredMap.entrySet();
136+
assertEquals(3, entries.size());
137+
138+
int expectedCount = 0;
139+
140+
for (Map.Entry<String, Object> entry : entries) {
141+
String key = entry.getKey();
142+
143+
if (key.equals(KEY_FILTERED)) {
144+
expectedCount++;
145+
assertEquals(PLACEHOLDER_FILTERED, entry.getValue());
146+
147+
} else if (key.equals(KEY_UNFILTERED)) {
148+
expectedCount++;
149+
assertEquals(VAL_UNFILTERED, entry.getValue());
150+
151+
} else if (key.equals(KEY_NESTED)) {
152+
expectedCount++;
153+
Object value = entry.getValue();
154+
assertTrue(value instanceof FilteredMap);
155+
}
156+
}
157+
assertEquals(3, expectedCount);
158+
}
159+
160+
}

0 commit comments

Comments
 (0)