1#!/usr/bin/env python 2# Copyright 2009 Google Inc. All Rights Reserved. 3# 4# Licensed under the Apache License, Version 2.0 (the "License"); 5# you may not use this file except in compliance with the License. 6# You may obtain a copy of the License at 7# 8# http://www.apache.org/licenses/LICENSE-2.0 9# 10# Unless required by applicable law or agreed to in writing, software 11# distributed under the License is distributed on an "AS IS" BASIS, 12# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13# See the License for the specific language governing permissions and 14# limitations under the License. 15 16"""Tests for the benchmark module.""" 17 18__author__ = 'tstromberg@google.com (Thomas Stromberg)' 19 20import unittest 21import benchmark 22import mocks 23 24class BenchmarkTest(unittest.TestCase): 25 def testCreateTestsWeighted(self): 26 b = benchmark.Benchmark([mocks.MockNameServer(mocks.GOOD_IP)], 27 test_count=1000) 28 results = b.CreateTests(('google.com', 'live.com')) 29 self.assertEquals(len(results), 1000) 30 self.assertTrue(('A', 'www.google.com.') in results) 31 caches = [x for x in results if 'cache' in x[1]] 32 self.assertTrue(len(caches) > 0 and len(caches) < 50) 33 34 def testCreateTestsSingle(self): 35 b = benchmark.Benchmark([mocks.MockNameServer(mocks.GOOD_IP)], 36 test_count=1) 37 results = b.CreateTests(('A mail.google.com',)) 38 self.assertEquals(results, [['A', 'mail.google.com']]) 39 # Oops, this isn't a real tuple. 40 self.assertRaises(AssertionError, b.CreateTests, 'google.com') 41 42 def testCreateTestsChunkRecords(self): 43 b = benchmark.Benchmark([mocks.MockNameServer(mocks.GOOD_IP)], 44 test_count=100) 45 results = b.CreateTests(('A mail.google.com', 'CNAME test.live.com'), 46 select_mode='chunk') 47 self.assertEquals(results, [['A', 'mail.google.com'], 48 ['CNAME', 'test.live.com']]) 49 50 def testEmptyRun(self): 51 ns_list = (mocks.MockNameServer(mocks.GOOD_IP),) 52 b = benchmark.Benchmark(ns_list, test_count=3, run_count=2) 53 self.assertRaises(AssertionError, b.Run) 54 55 def testRun(self): 56 ns_list = (mocks.MockNameServer(mocks.GOOD_IP), 57 mocks.MockNameServer(mocks.PERFECT_IP), 58 mocks.MockNameServer(mocks.BROKEN_IP), 59 mocks.MockNameServer(mocks.SLOW_IP)) 60 b = benchmark.Benchmark(ns_list, test_count=3, run_count=2) 61 self.assertRaises(AssertionError, b.Run) 62 b.CreateTests(['A www.google.com']) 63 self.assertEquals(b.test_data, [['A', 'www.google.com'], 64 ['A', 'www.google.com'], 65 ['A', 'www.google.com']]) 66 b.Run() 67 ips_tested = sorted([ x.ip for x in b.results ]) 68 expected = ['127.0.0.1', '127.127.127.127', '192.168.0.1', '9.9.9.9'] 69 self.assertEquals(ips_tested, expected) 70 self.assertEquals(len(b.results[ns_list[0]]), 2) 71 self.assertEquals(len(b.results[ns_list[0]][0]), 3) 72 73 def testNormalRun(self): 74 ns_list = (mocks.MockNameServer(mocks.GOOD_IP), 75 mocks.MockNameServer(mocks.PERFECT_IP), 76 mocks.MockNameServer(mocks.BROKEN_IP), 77 mocks.MockNameServer(mocks.SLOW_IP)) 78 b = benchmark.Benchmark(ns_list, test_count=3, run_count=2) 79 b.CreateTests(['google.com', 'live.com']) 80 b.Run() 81 expected = ['127.0.0.1', '127.127.127.127', '192.168.0.1', '9.9.9.9'] 82 averages = dict([(x[0].ip, x[1]) for x in b.ComputeAverages()]) 83 self.assertEquals(len(averages), 4) 84 self.assertTrue(averages[mocks.GOOD_IP] >= 8) 85 self.assertTrue(averages[mocks.PERFECT_IP] <= 5) 86 self.assertTrue(averages[mocks.BROKEN_IP] >= 59) 87 self.assertTrue(averages[mocks.SLOW_IP] >= 20) 88 self.assertEquals(b.BestOverallNameServer(), ns_list[1]) 89 self.assertEquals(b.NearestNameServers(count=2), [ns_list[1], ns_list[0]]) 90 91 92 def testDigestion(self): 93 ns_list = (mocks.MockNameServer(mocks.GOOD_IP), 94 mocks.MockNameServer(mocks.PERFECT_IP), 95 mocks.MockNameServer(mocks.BROKEN_IP), 96 mocks.MockNameServer(mocks.SLOW_IP)) 97 b = benchmark.Benchmark(ns_list) 98 good = ns_list[0].FakeAnswer(None) 99 bad = ns_list[0].FakeAnswer(None, no_answer=True) 100 101 b.results = { 102 ns_list[0]: [[('www.google.com.', 'A', 2.90, bad), 103 ('google.com.', 'A', 9.80, good), 104 ('www.google.com.', 'A', 9.90, good)], 105 [('www.google.com.', 'A', 9.90, bad), 106 ('google.com.', 'A', 9.90, good), 107 ('www.google.com.', 'A', 9.80, good)]], 108 ns_list[1]: [[('www.google.com.', 'A', 3.40, good), 109 ('google.com.', 'A', 3.40, good), 110 ('www.google.com.', 'A', 3.60, good)], 111 [('www.google.com.', 'A', 3.30, good), 112 ('google.com.', 'A', 3.30, good), 113 ('www.google.com.', 'A', 3.40, good)]], 114 ns_list[2]: [[('www.google.com.', 'A', 60, None), 115 ('google.com.', 'A', 60, None), 116 ('www.google.com.', 'A', 60, None)], 117 [('www.google.com.', 'A', 60, None), 118 ('google.com.', 'A', 60, None), 119 ('www.google.com.', 'A', 60, None)]], 120 ns_list[3]: [[('www.google.com.', 'A', 26.25, good), 121 ('google.com.', 'A', 26.30, good), 122 ('www.google.com.', 'A', 26.10, good)], 123 [('www.google.com.', 'A', 26.40, good), 124 ('google.com.', 'A', 12.40, bad), 125 ('www.google.com.', 'A', 26.80, good)]]} 126 127 expected = [] 128 averages = dict([(x[0].ip, x[1]) for x in b.ComputeAverages()]) 129 self.assertEquals(averages[mocks.GOOD_IP], 8.7000000000000011) 130 self.assertEquals(averages[mocks.PERFECT_IP], 3.4000000000000004) 131 self.assertEquals(averages[mocks.BROKEN_IP], 60) 132 self.assertEquals(averages[mocks.SLOW_IP],24.041666666666664) 133 134 expected = [('127.127.127.127', 3.2999999999999998), 135 ('127.0.0.1', 9.80), 136 ('9.9.9.9', 26.10), 137 ('192.168.0.1', 60)] 138 fastest = [(x[0].ip, x[1]) for x in b.FastestNameServerResult()] 139 self.assertEquals(fastest, expected) 140 141 expected = [ 142 (None, '####', 3.2999999999999998), 143 (None, '##########', 9.8000000000000007), 144 (None, '###########################', 26.100000000000001), 145 (None, '############################################################', 146 60) 147 ] 148 self.assertEquals(b._LowestLatencyAsciiChart(), expected) 149 150 def testFastest(self): 151 ns_list = (mocks.MockNameServer('X', name='X'), 152 mocks.MockNameServer('O', name='O'), 153 mocks.MockNameServer('U', name='U')) 154 b = benchmark.Benchmark(ns_list) 155 good = ns_list[0].FakeAnswer(None) 156 b.results = { 157 ns_list[0]: [[('www.microsoft.com.', 'A', 3.0879974365234375, good), 158 ('www.youku.com.', 'A', 2.2590160369873047, good), 159 ('www.orkut.co.in.', 'A', 25.511980056762695, good), 160 ('cache-9.ku6.com.', 'A', 1013.6392116546631, good), 161 ('wsj.com.', 'A', 2.3639202117919922, good), 162 ('www.imagevenue.com.', 'A', 2.6688575744628906, good), 163 ('www.travian.ae.', 'A', 2.5160312652587891, good), 164 ('www.fotolog.net.', 'A', 2.6750564575195312, good), 165 ('www.torrentz.com.', 'A', 2.7811527252197266, good), 166 ('www.wer-kennt-wen.de.', 'A', 2.7070045471191406, good)]], 167 ns_list[1]: [[('www.microsoft.com.', 'A', 82.499980926513672, good), 168 ('www.youku.com.', 'A', 81.991195678710938, good), 169 ('www.orkut.co.in.', 'A', 82.377910614013672, good), 170 ('cache-9.ku6.com.', 'A', 1141.1499977111816, good), 171 ('wsj.com.', 'A', 84.334135055541992, good), 172 ('www.imagevenue.com.', 'A', 84.282875061035156, good), 173 ('www.travian.ae.', 'A', 84.036111831665039, good), 174 ('www.fotolog.net.', 'A', 84.750175476074219, good), 175 ('www.torrentz.com.', 'A', 84.517002105712891, good), 176 ('www.wer-kennt-wen.de.', 'A', 83.980083465576172, good)]], 177 ns_list[2]: [[('www.microsoft.com.', 'A', 12.507915496826172, good), 178 ('www.youku.com.', 'A', 357.06806182861328, good), 179 ('www.orkut.co.in.', 'A', 46.499967575073242, good), 180 ('cache-9.ku6.com.', 'A', 697.60799407958984, good), 181 ('wsj.com.', 'A', 87.159872055053711, good), 182 ('www.imagevenue.com.', 'A', 11.99793815612793, good), 183 ('www.travian.ae.', 'A', 11.492013931274414, good), 184 ('www.fotolog.net.', 'A', 12.087106704711914, good), 185 ('www.torrentz.com.', 'A', 12.598991394042969, good), 186 ('www.wer-kennt-wen.de.', 'A', 11.770963668823242, good)]] 187 } 188 189 expected = [('G', 2.2590160369873047), 190 ('U', 11.492013931274414), 191 ('O', 81.991195678710938)] 192 fastest = [(x[0].ip, x[1]) for x in b.FastestNameServerResult()] 193 self.assertEquals(fastest, expected) 194 195 expected = [ 196 ('X', '##', 2.2590160369873047), 197 ('U', '########', 11.492013931274414), 198 ('O', '#####################################################', 199 81.991195678710938) 200 ] 201 self.assertEquals(b._LowestLatencyAsciiChart(), expected) 202 203 204 205if __name__ == '__main__': 206 unittest.main() 207