mocks.GOOD_IP

Here are the examples of the python api mocks.GOOD_IP taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

20 Examples 7

Example 1

Project: namebench Source File: benchmark_test.py
  def testCreateTestsWeighted(self):
    b = benchmark.Benchmark([mocks.MockNameServer(mocks.GOOD_IP)],
                            test_count=1000)
    results = b.CreateTests(('google.com', 'live.com'))
    self.assertEquals(len(results), 1000)
    self.assertTrue(('A', 'www.google.com.') in results)
    caches = [x for x in results if 'cache' in x[1]]
    self.assertTrue(len(caches) > 0 and len(caches) < 50)

Example 2

Project: namebench Source File: benchmark_test.py
  def testCreateTestsSingle(self):
    b = benchmark.Benchmark([mocks.MockNameServer(mocks.GOOD_IP)],
                            test_count=1)
    results = b.CreateTests(('A mail.google.com',))
    self.assertEquals(results, [['A', 'mail.google.com']])
    # Oops, this isn't a real tuple.
    self.assertRaises(AssertionError, b.CreateTests, 'google.com')

Example 3

Project: namebench Source File: benchmark_test.py
  def testCreateTestsChunkRecords(self):
    b = benchmark.Benchmark([mocks.MockNameServer(mocks.GOOD_IP)],
                            test_count=100)
    results = b.CreateTests(('A mail.google.com', 'CNAME test.live.com'),
                            select_mode='chunk')
    self.assertEquals(results, [['A', 'mail.google.com'],
                                ['CNAME', 'test.live.com']])

Example 4

Project: namebench Source File: benchmark_test.py
Function: test_run
  def testRun(self):
    ns_list = (mocks.MockNameServer(mocks.GOOD_IP),
               mocks.MockNameServer(mocks.PERFECT_IP),
               mocks.MockNameServer(mocks.BROKEN_IP),
               mocks.MockNameServer(mocks.SLOW_IP))
    b = benchmark.Benchmark(ns_list, test_count=3, run_count=2)
    self.assertRaises(AssertionError, b.Run)
    b.CreateTests(['A www.google.com'])
    self.assertEquals(b.test_data,  [['A', 'www.google.com'],
                                     ['A', 'www.google.com'],
                                     ['A', 'www.google.com']])
    b.Run()
    ips_tested = sorted([ x.ip for x in b.results ])
    expected = ['127.0.0.1', '127.127.127.127', '192.168.0.1', '9.9.9.9']
    self.assertEquals(ips_tested, expected)
    self.assertEquals(len(b.results[ns_list[0]]), 2)
    self.assertEquals(len(b.results[ns_list[0]][0]), 3)

Example 5

Project: namebench Source File: benchmark_test.py
Function: test_normal_run
  def testNormalRun(self):
    ns_list = (mocks.MockNameServer(mocks.GOOD_IP),
               mocks.MockNameServer(mocks.PERFECT_IP),
               mocks.MockNameServer(mocks.BROKEN_IP),
               mocks.MockNameServer(mocks.SLOW_IP))
    b = benchmark.Benchmark(ns_list, test_count=3, run_count=2)
    b.CreateTests(['google.com', 'live.com'])
    b.Run()
    expected = ['127.0.0.1', '127.127.127.127', '192.168.0.1', '9.9.9.9']
    averages = dict([(x[0].ip, x[1]) for x in b.ComputeAverages()])
    self.assertEquals(len(averages), 4)
    self.assertTrue(averages[mocks.GOOD_IP] >= 8)
    self.assertTrue(averages[mocks.PERFECT_IP] <= 5)
    self.assertTrue(averages[mocks.BROKEN_IP] >= 59)
    self.assertTrue(averages[mocks.SLOW_IP] >= 20)
    self.assertEquals(b.BestOverallNameServer(), ns_list[1])
    self.assertEquals(b.NearestNameServers(count=2), [ns_list[1], ns_list[0]])

Example 6

Project: namebench Source File: nameserver_test.py
Function: test_init
  def testInit(self):
    ns = mocks.MockNameServer(mocks.GOOD_IP)
    self.assertEquals(ns.ip, mocks.GOOD_IP)
    self.assertEquals(ns.name, None)

    ns = mocks.MockNameServer(mocks.NO_RESPONSE_IP, name='Broked')
    self.assertEquals(ns.ip, mocks.NO_RESPONSE_IP)
    self.assertEquals(ns.name, 'Broked')

Example 7

Project: namebench Source File: nameserver_test.py
  def testTimedRequest(self):
    ns = mocks.MockNameServer(mocks.GOOD_IP)
    (response, duration, exception) = ns.TimedRequest('A', 'www.paypal.com')
    self.assertEquals(response.id, 999)
    expected = ('www.paypal.com. 159 IN A 66.211.169.65\n'
                'www.paypal.com. 159 IN A 66.211.169.2')
    self.assertEquals(str(response.answer[0]), expected)
    self.assertTrue(duration > 0)
    self.assertEquals(exception, None)

Example 8

Project: namebench Source File: nameserver_test.py
  def testTestAnswers(self):
     ns = mocks.MockNameServer(mocks.GOOD_IP)
     (is_broken, warning, duration) = ns.TestAnswers('A', 'www.paypal.com',
                                                     '10.0.0.1')
     self.assertEquals(is_broken, False)
     self.assertEquals(warning, None)
     self.assertTrue(duration > 0 and duration < 3600)

Example 9

Project: namebench Source File: nameserver_test.py
  def testResponseToAscii(self):
    ns = mocks.MockNameServer(mocks.GOOD_IP)
    (response, duration, exception) = ns.TimedRequest('A', 'www.paypal.com')
    self.assertEquals(nameserver.ResponseToAscii(response),
                      '66.211.169.65 + 66.211.169.2')
    response.answer = None
    self.assertEquals(nameserver.ResponseToAscii(response), 'no answer')

Example 10

Project: namebench Source File: nameserver_test.py
  def testGoogleComResponse(self):
    ns = mocks.MockNameServer(mocks.GOOD_IP)
    (is_broken, warning, duration) = ns.TestGoogleComResponse()
    self.assertEquals(is_broken, False)
    self.assertEquals(warning,
                      'google.com. is hijacked (66.211.169.65 + 66.211.169.2)')
    self.assertTrue(duration > 0 and duration < 3600)

Example 11

Project: namebench Source File: nameserver_test.py
  def testWwwGoogleComResponse(self):
    ns = mocks.MockNameServer(mocks.GOOD_IP)
    (is_broken, warning, duration) = ns.TestWwwGoogleComResponse()
    self.assertEquals(is_broken, True)
    self.assertEquals(warning, 'No answer')
    self.assertTrue(duration > 0 and duration < 3600)

Example 12

Project: namebench Source File: nameserver_test.py
  def testNegativeResponseHijacked(self):
    ns = mocks.MockNameServer(mocks.GOOD_IP)
    (is_broken, warning, duration) = ns.TestNegativeResponse()
    self.assertEquals(is_broken, False)
    self.assertEquals(warning,
                      'NXDOMAIN Hijacking (66.211.169.65 + 66.211.169.2)')

Example 13

Project: namebench Source File: nameserver_test.py
  def testWildcardCache(self):
    ns = mocks.MockNameServer(mocks.GOOD_IP)
    (response, is_broken, warning, duration) = ns.QueryWildcardCache()
    self.assertEquals(is_broken, False)
    question = str(response.question[0])
    self.assertTrue(question.startswith('namebench'))
    self.assertEquals(warning, None)

Example 14

Project: namebench Source File: nameserver_test.py
  def testCheckHealthGood(self):
    ns = mocks.MockNameServer(mocks.GOOD_IP)
    ns.CheckHealth()
    self.assertEquals(ns.CheckHealth(), False)
    self.assertEquals(ns.warnings, ['No answer'])
    self.assertEquals(len(ns.checks), 1)
    self.assertEquals(ns.failure[0], 'TestWwwGoogleComResponse')
    self.assertEquals(ns.checks[0][0:3],
                      ('TestWwwGoogleComResponse', True, 'No answer'))

Example 15

Project: namebench Source File: nameserver_test.py
  def testQUeryWildcardCacheSaving(self):
    ns = mocks.MockNameServer(mocks.GOOD_IP)
    other_ns = mocks.MockNameServer(mocks.PERFECT_IP)
    ns.QueryWildcardCache(save=True)
    other_ns.QueryWildcardCache(save=True)

    # Test our cache-sharing mechanisms
    (hostname, ttl) = ns.cache_check
    self.assertTrue(hostname.startswith('namebench'))
    self.assertEquals(ttl, 159)
    (other_hostname, other_ttl) = other_ns.cache_check
    self.assertTrue(other_hostname.startswith('namebench'))
    self.assertNotEqual(hostname, other_hostname)
    self.assertEquals(other_ttl, 159)

Example 16

Project: namebench Source File: nameserver_test.py
  def testSharedCacheNoMatch(self):
    ns = mocks.MockNameServer(mocks.GOOD_IP)
    other_ns = mocks.MockNameServer(mocks.PERFECT_IP)
    ns.QueryWildcardCache(save=True)
    other_ns.QueryWildcardCache(save=True)
    (shared, slower, faster) = ns.TestSharedCache(other_ns)
    self.assertEquals(shared, False)
    self.assertEquals(slower, None)
    self.assertEquals(faster, None)

Example 17

Project: namebench Source File: nameserver_test.py
  def testSharedCacheMatch(self):
    ns = mocks.MockNameServer(mocks.GOOD_IP)
    other_ns = mocks.MockNameServer(mocks.PERFECT_IP)
    ns.QueryWildcardCache(save=True)
    other_ns.QueryWildcardCache(save=True)
    # Increase the TTL of 'other'
    other_ns.cache_check = (other_ns.cache_check[0], other_ns.cache_check[1] + 5)
    (shared, slower, faster) = ns.TestSharedCache(other_ns)
    self.assertEquals(shared, True)
    self.assertEquals(slower.ip, mocks.GOOD_IP)
    self.assertEquals(faster.ip, mocks.PERFECT_IP)


    # Increase the TTL of 'other' by a whole lot
    other_ns.cache_check = (other_ns.cache_check[0], other_ns.cache_check[1] + 3600)
    (shared, slower, faster) = ns.TestSharedCache(other_ns)
    self.assertEquals(shared, False)
    self.assertEquals(slower, None)
    self.assertEquals(faster, None)

Example 18

Project: namebench Source File: benchmark_test.py
Function: test_empty_run
  def testEmptyRun(self):
    ns_list = (mocks.MockNameServer(mocks.GOOD_IP),)
    b = benchmark.Benchmark(ns_list, test_count=3, run_count=2)
    self.assertRaises(AssertionError, b.Run)

Example 19

Project: namebench Source File: benchmark_test.py
  def testDigestion(self):
    ns_list = (mocks.MockNameServer(mocks.GOOD_IP),
               mocks.MockNameServer(mocks.PERFECT_IP),
               mocks.MockNameServer(mocks.BROKEN_IP),
               mocks.MockNameServer(mocks.SLOW_IP))
    b = benchmark.Benchmark(ns_list)
    good = ns_list[0].FakeAnswer(None)
    bad = ns_list[0].FakeAnswer(None, no_answer=True)

    b.results = {
     ns_list[0]: [[('www.google.com.', 'A', 2.90, bad),
                   ('google.com.', 'A', 9.80, good),
                   ('www.google.com.', 'A', 9.90, good)],
                 [('www.google.com.', 'A', 9.90, bad),
                  ('google.com.', 'A', 9.90, good),
                  ('www.google.com.', 'A', 9.80, good)]],
     ns_list[1]: [[('www.google.com.', 'A', 3.40, good),
                   ('google.com.', 'A', 3.40, good),
                   ('www.google.com.', 'A', 3.60, good)],
                  [('www.google.com.', 'A', 3.30, good),
                   ('google.com.', 'A', 3.30, good),
                   ('www.google.com.', 'A', 3.40, good)]],
     ns_list[2]: [[('www.google.com.', 'A', 60, None),
                   ('google.com.', 'A', 60, None),
                   ('www.google.com.', 'A', 60, None)],
                   [('www.google.com.', 'A', 60, None),
                    ('google.com.', 'A', 60, None),
                    ('www.google.com.', 'A', 60, None)]],
     ns_list[3]: [[('www.google.com.', 'A', 26.25, good),
                   ('google.com.', 'A', 26.30, good),
                   ('www.google.com.', 'A', 26.10, good)],
                  [('www.google.com.', 'A', 26.40, good),
                   ('google.com.', 'A', 12.40, bad),
                   ('www.google.com.', 'A', 26.80, good)]]}

    expected = []
    averages = dict([(x[0].ip, x[1]) for x in b.ComputeAverages()])
    self.assertEquals(averages[mocks.GOOD_IP], 8.7000000000000011)
    self.assertEquals(averages[mocks.PERFECT_IP], 3.4000000000000004)
    self.assertEquals(averages[mocks.BROKEN_IP], 60)
    self.assertEquals(averages[mocks.SLOW_IP],24.041666666666664)

    expected = [('127.127.127.127', 3.2999999999999998),
                ('127.0.0.1', 9.80),
                ('9.9.9.9', 26.10),
                ('192.168.0.1', 60)]
    fastest = [(x[0].ip, x[1]) for x in b.FastestNameServerResult()]
    self.assertEquals(fastest, expected)

    expected = [
        (None, '####', 3.2999999999999998),
        (None, '##########', 9.8000000000000007),
        (None, '###########################', 26.100000000000001),
        (None, '############################################################',
         60)
    ]
    self.assertEquals(b._LowestLatencyAsciiChart(), expected)

Example 20

Project: namebench Source File: nameserver_test.py
  def testWwwPaypalComResponse(self):
    ns = mocks.MockNameServer(mocks.GOOD_IP)
    (is_broken, warning, duration) = ns.TestWwwPaypalComResponse()
    self.assertEquals(is_broken, False)
    self.assertEquals(warning, None)