浏览代码

Minor updater test improvements/additions

Change-Id: I83f60d4bc11aac49a86f50d3aea66e6ab508386a
Reviewed-on: http://gerrit.dmdirc.com/3205
Automatic-Compile: DMDirc Build Manager
Reviewed-by: Greg Holmes <greg@dmdirc.com>
tags/0.8rc1
Chris Smith 10 年前
父节点
当前提交
9dc1c26ab7

+ 46
- 60
test/com/dmdirc/updater/checking/NaiveConsolidatorTest.java 查看文件

@@ -31,103 +31,89 @@ import java.util.Map;
31 31
 
32 32
 import org.junit.Before;
33 33
 import org.junit.Test;
34
+import org.junit.runner.RunWith;
35
+import org.mockito.Mock;
36
+import org.mockito.runners.MockitoJUnitRunner;
34 37
 
35
-import static org.junit.Assert.*;
36
-import static org.mockito.Mockito.*;
38
+import static org.junit.Assert.assertEquals;
39
+import static org.junit.Assert.assertSame;
40
+import static org.junit.Assert.assertTrue;
41
+import static org.mockito.Mockito.when;
37 42
 
43
+@RunWith(MockitoJUnitRunner.class)
38 44
 public class NaiveConsolidatorTest {
39 45
 
40 46
     private NaiveConsolidator consolidator;
41
-    private List<UpdateComponent> components;
42
-    private List<UpdateCheckResult> positiveResults;
43
-    private List<UpdateCheckResult> negativeResults;
47
+
48
+    @Mock private UpdateComponent component1;
49
+    @Mock private UpdateComponent component2;
50
+    @Mock private UpdateComponent component3;
51
+    @Mock private UpdateCheckResult availableResult;
52
+    @Mock private UpdateCheckResult unavailableResult;
44 53
 
45 54
     @Before
46 55
     public void setUp() {
56
+        when(availableResult.isUpdateAvailable()).thenReturn(true);
57
+        when(unavailableResult.isUpdateAvailable()).thenReturn(false);
47 58
         consolidator = new NaiveConsolidator();
48
-        components = new ArrayList<>();
49
-        positiveResults = new ArrayList<>();
50
-        negativeResults = new ArrayList<>();
51
-
52
-        for (int i = 0; i < 4; i++) {
53
-            final UpdateComponent component = mock(UpdateComponent.class);
54
-            final UpdateCheckResult negative = mock(UpdateCheckResult.class);
55
-            final UpdateCheckResult positive = mock(UpdateCheckResult.class);
56
-            when(negative.getComponent()).thenReturn(component);
57
-            when(negative.isUpdateAvailable()).thenReturn(false);
58
-            when(positive.getComponent()).thenReturn(component);
59
-            when(positive.isUpdateAvailable()).thenReturn(true);
60
-
61
-            components.add(component);
62
-            negativeResults.add(negative);
63
-            positiveResults.add(negative);
64
-        }
65 59
     }
66 60
 
67 61
     @Test
68 62
     public void testIncludesAllComponentsFromAllMaps() {
69
-        final Map<UpdateComponent, UpdateCheckResult> map1
70
-                = new HashMap<>();
71
-        final Map<UpdateComponent, UpdateCheckResult> map2
72
-                = new HashMap<>();
73
-        final List<Map<UpdateComponent, UpdateCheckResult>> maps
74
-                = new ArrayList<>();
63
+        final Map<UpdateComponent, UpdateCheckResult> map1 = new HashMap<>();
64
+        map1.put(component1, unavailableResult);
65
+        map1.put(component2, unavailableResult);
75 66
 
76
-        map1.put(components.get(0), negativeResults.get(0));
77
-        map1.put(components.get(1), negativeResults.get(1));
78
-        map2.put(components.get(2), negativeResults.get(2));
67
+        final Map<UpdateComponent, UpdateCheckResult> map2 = new HashMap<>();
68
+        map2.put(component3, unavailableResult);
79 69
 
70
+        final List<Map<UpdateComponent, UpdateCheckResult>> maps = new ArrayList<>();
80 71
         maps.add(map1);
81 72
         maps.add(map2);
82 73
 
83 74
         final Map<UpdateComponent, UpdateCheckResult> res = consolidator.consolidate(maps);
84 75
         assertEquals(3, res.size());
85
-        assertTrue(res.containsKey(components.get(0)));
86
-        assertTrue(res.containsKey(components.get(1)));
87
-        assertTrue(res.containsKey(components.get(2)));
76
+        assertTrue(res.containsKey(component1));
77
+        assertTrue(res.containsKey(component2));
78
+        assertTrue(res.containsKey(component3));
88 79
     }
89 80
 
90 81
     @Test
91 82
     public void testIncludesPositiveResultsForKnownNegativeComponents() {
92
-        final Map<UpdateComponent, UpdateCheckResult> map1
93
-                = new HashMap<>();
94
-        final Map<UpdateComponent, UpdateCheckResult> map2
95
-                = new HashMap<>();
96
-        final List<Map<UpdateComponent, UpdateCheckResult>> maps
97
-                = new ArrayList<>();
98
-
99
-        map1.put(components.get(0), negativeResults.get(0));
100
-        map1.put(components.get(1), negativeResults.get(1));
101
-        map2.put(components.get(1), positiveResults.get(1));
102
-        map2.put(components.get(2), negativeResults.get(2));
83
+        final Map<UpdateComponent, UpdateCheckResult> map1 = new HashMap<>();
84
+        map1.put(component2, unavailableResult);
85
+        map1.put(component1, unavailableResult);
86
+
87
+        final Map<UpdateComponent, UpdateCheckResult> map2 = new HashMap<>();
88
+        map2.put(component2, availableResult);
89
+        map2.put(component3, unavailableResult);
103 90
 
91
+        final List<Map<UpdateComponent, UpdateCheckResult>> maps = new ArrayList<>();
104 92
         maps.add(map1);
105 93
         maps.add(map2);
106 94
 
107 95
         final Map<UpdateComponent, UpdateCheckResult> res = consolidator.consolidate(maps);
108
-        assertTrue(res.containsKey(components.get(1)));
109
-        assertSame(positiveResults.get(1), res.get(components.get(1)));
96
+        assertTrue(res.containsKey(component2));
97
+        assertSame(availableResult, res.get(component2));
110 98
     }
111 99
 
112 100
     @Test
113 101
     public void testIgnoresNegativeResultsForKnownPositiveComponents() {
114
-        final Map<UpdateComponent, UpdateCheckResult> map1
115
-                = new HashMap<>();
116
-        final Map<UpdateComponent, UpdateCheckResult> map2
117
-                = new HashMap<>();
118
-        final List<Map<UpdateComponent, UpdateCheckResult>> maps
119
-                = new ArrayList<>();
120
-
121
-        map1.put(components.get(0), negativeResults.get(0));
122
-        map1.put(components.get(1), positiveResults.get(1));
123
-        map2.put(components.get(1), negativeResults.get(1));
124
-        map2.put(components.get(2), negativeResults.get(2));
102
+        final Map<UpdateComponent, UpdateCheckResult> map1 = new HashMap<>();
103
+        map1.put(component1, unavailableResult);
104
+        map1.put(component2, availableResult);
125 105
 
106
+        final Map<UpdateComponent, UpdateCheckResult> map2 = new HashMap<>();
107
+        map2.put(component2, unavailableResult);
108
+        map2.put(component3, unavailableResult);
109
+
110
+        final List<Map<UpdateComponent, UpdateCheckResult>> maps = new ArrayList<>();
126 111
         maps.add(map1);
127 112
         maps.add(map2);
128 113
 
129 114
         final Map<UpdateComponent, UpdateCheckResult> res = consolidator.consolidate(maps);
130
-        assertTrue(res.containsKey(components.get(1)));
131
-        assertSame(positiveResults.get(1), res.get(components.get(1)));
115
+        assertTrue(res.containsKey(component2));
116
+        assertSame(availableResult, res.get(component2));
132 117
     }
118
+
133 119
 }

+ 78
- 0
test/com/dmdirc/updater/manager/CachingUpdateManagerImplTest.java 查看文件

@@ -0,0 +1,78 @@
1
+/*
2
+ * Copyright (c) 2006-2014 DMDirc Developers
3
+ *
4
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
5
+ * of this software and associated documentation files (the "Software"), to deal
6
+ * in the Software without restriction, including without limitation the rights
7
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8
+ * copies of the Software, and to permit persons to whom the Software is
9
+ * furnished to do so, subject to the following conditions:
10
+ *
11
+ * The above copyright notice and this permission notice shall be included in
12
+ * all copies or substantial portions of the Software.
13
+ *
14
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20
+ * SOFTWARE.
21
+ */
22
+
23
+package com.dmdirc.updater.manager;
24
+
25
+import com.dmdirc.updater.UpdateComponent;
26
+import com.dmdirc.updater.checking.CheckResultConsolidator;
27
+
28
+import java.util.concurrent.Executor;
29
+
30
+import org.junit.Before;
31
+import org.junit.Test;
32
+import org.junit.runner.RunWith;
33
+import org.mockito.Mock;
34
+import org.mockito.runners.MockitoJUnitRunner;
35
+
36
+import static org.junit.Assert.assertEquals;
37
+import static org.mockito.Mockito.when;
38
+
39
+@RunWith(MockitoJUnitRunner.class)
40
+public class CachingUpdateManagerImplTest {
41
+
42
+    @Mock private CheckResultConsolidator consolidator;
43
+    @Mock private UpdateComponentPolicy policy;
44
+    @Mock private UpdateComponent checkableComponent;
45
+    @Mock private UpdateComponent uncheckableComponent;
46
+    private CachingUpdateManagerImpl manager;
47
+
48
+    @Before
49
+    public void setup() {
50
+        manager = new CachingUpdateManagerImpl(new CurrentThreadExecutor(), consolidator, policy);
51
+        when(policy.canCheck(checkableComponent)).thenReturn(true);
52
+        when(policy.canCheck(uncheckableComponent)).thenReturn(false);
53
+        when(checkableComponent.getName()).thenReturn("checkable");
54
+        when(uncheckableComponent.getName()).thenReturn("uncheckable");
55
+    }
56
+
57
+    @Test
58
+    public void testCheckableComponentShownAsIdleWhenAdded() {
59
+        manager.addComponent(checkableComponent);
60
+        assertEquals(UpdateStatus.IDLE, manager.getStatus(checkableComponent));
61
+    }
62
+
63
+    @Test
64
+    public void testUncheckableComponentShownAsNotPermittedWhenAdded() {
65
+        manager.addComponent(uncheckableComponent);
66
+        assertEquals(UpdateStatus.CHECKING_NOT_PERMITTED, manager.getStatus(uncheckableComponent));
67
+    }
68
+
69
+    private static class CurrentThreadExecutor implements Executor {
70
+
71
+        @Override
72
+        public void execute(final Runnable r) {
73
+            r.run();
74
+        }
75
+
76
+    }
77
+
78
+}

正在加载...
取消
保存