#!/usr/bin/env python2.7
#
# Copyright 2007 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
"""Tests for google.apphosting.tools.devappserver2.instance."""


import time
import unittest

import google
import mox

from google.appengine.tools.devappserver2 import instance
from google.appengine.tools.devappserver2 import wsgi_request_info


class TestInstance(unittest.TestCase):
  """Tests for instance.Instance."""

  def setUp(self):
    self.mox = mox.Mox()
    self.proxy = self.mox.CreateMock(instance.RuntimeProxy)
    self.environ = object()
    self.start_response = object()
    self.url_map = object()
    self.match = object()
    self.request_id = object()
    self.response = [object()]
    self.request_data = self.mox.CreateMock(wsgi_request_info.WSGIRequestInfo)

  def tearDown(self):
    self.mox.UnsetStubs()

  def test_new_instance(self):
    inst = instance.Instance(
        self.request_data, 'name', self.proxy, max_concurrent_requests=5,
        expect_ready_request=True)
    self.assertEqual(0, inst.total_requests)
    self.assertEqual(5, inst.remaining_request_capacity)
    self.assertEqual(0, inst.num_outstanding_requests)
    self.assertFalse(inst.can_accept_requests)
    self.assertTrue(inst.handling_ready_request)
    self.assertAlmostEqual(0, inst.idle_seconds, places=2)
    self.assertEqual(0, inst.get_latency_60s())
    self.assertEqual(0, inst.get_qps_60s())
    self.assertEqual('name', inst.instance_id)

  def test_handle(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5)
    self.mox.StubOutWithMock(inst._condition, 'notify')

    self.proxy.start()
    self.environ = {}
    self.request_data.set_request_instance(self.request_id, inst)
    self.proxy.handle(self.environ,
                      self.start_response,
                      self.url_map,
                      self.match,
                      self.request_id,
                      instance.NORMAL_REQUEST).AndReturn(self.response)
    inst._condition.notify()
    self.mox.ReplayAll()
    now = time.time()
    inst._request_history.append((now - 100, now - 80))
    inst.start()
    self.assertTrue(inst.can_accept_requests)
    self.assertEqual(
        self.response,
        list(inst.handle(self.environ,
                         self.start_response,
                         self.url_map,
                         self.match,
                         self.request_id,
                         instance.NORMAL_REQUEST)))
    self.mox.VerifyAll()

    self.assertEqual(1, len(inst._request_history))
    self.assertEqual(1, inst.total_requests)
    self.assertEqual(5, inst.remaining_request_capacity)
    self.assertEqual(0, inst.num_outstanding_requests)
    self.assertTrue(0 < inst.get_qps_60s())

  def test_handle_ready_request(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5,
                             expect_ready_request=True)
    self.mox.StubOutWithMock(inst._condition, 'notify')

    self.proxy.start()
    self.environ = {}
    self.request_data.set_request_instance(self.request_id, inst)
    self.proxy.handle(self.environ,
                      self.start_response,
                      self.url_map,
                      self.match,
                      self.request_id,
                      instance.READY_REQUEST).AndReturn(self.response)
    inst._condition.notify(5)
    self.mox.ReplayAll()
    inst.start()
    self.assertFalse(inst.can_accept_requests)
    self.assertRaises(instance.CannotAcceptRequests,
                      inst.handle,
                      self.environ,
                      self.start_response,
                      self.url_map,
                      self.match,
                      self.request_id,
                      instance.NORMAL_REQUEST)
    self.assertEqual(
        self.response,
        list(inst.handle(self.environ,
                         self.start_response,
                         self.url_map,
                         self.match,
                         self.request_id,
                         instance.READY_REQUEST)))
    self.mox.VerifyAll()

    self.assertEqual(1, inst.total_requests)
    self.assertEqual(5, inst.remaining_request_capacity)
    self.assertEqual(0, inst.num_outstanding_requests)
    self.assertTrue(0 < inst.get_qps_60s())
    self.assertFalse(inst.handling_ready_request)

  def test_handle_background_request(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5,
                             max_background_threads=2)
    inst._num_running_background_threads = 1
    self.mox.StubOutWithMock(inst._condition, 'notify')

    self.proxy.start()
    self.environ = {}
    self.request_data.set_request_instance(self.request_id, inst)
    self.proxy.handle(self.environ,
                      self.start_response,
                      self.url_map,
                      self.match,
                      self.request_id,
                      instance.BACKGROUND_REQUEST).AndReturn(self.response)
    self.mox.ReplayAll()
    inst.start()
    self.assertTrue(inst.can_accept_requests)
    self.assertEqual(1, inst.remaining_background_thread_capacity)
    self.assertEqual(
        self.response,
        list(inst.handle(self.environ,
                         self.start_response,
                         self.url_map,
                         self.match,
                         self.request_id,
                         instance.BACKGROUND_REQUEST)))
    self.mox.VerifyAll()

    self.assertEqual(1, inst.total_requests)
    self.assertEqual(5, inst.remaining_request_capacity)
    self.assertEqual(0, inst.num_outstanding_requests)
    self.assertTrue(0 < inst.get_qps_60s())
    self.assertEqual(2, inst.remaining_background_thread_capacity)
    self.assertFalse(inst.handling_ready_request)

  def test_handle_shutdown_request(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=1)
    inst._num_outstanding_requests = 0
    self.mox.StubOutWithMock(inst._condition, 'notify_all')

    self.proxy.start()
    self.environ = {}
    self.request_data.set_request_instance(self.request_id, inst)
    self.proxy.handle(self.environ,
                      self.start_response,
                      self.url_map,
                      self.match,
                      self.request_id,
                      instance.SHUTDOWN_REQUEST).AndReturn(self.response)
    self.proxy.quit()
    inst._condition.notify_all()
    self.mox.ReplayAll()
    inst.start()
    self.assertTrue(inst.can_accept_requests)
    self.assertFalse(inst.has_quit)
    inst.quit(expect_shutdown=True)
    self.assertFalse(inst.can_accept_requests)
    self.assertTrue(inst.has_quit)
    self.assertEqual(
        self.response,
        list(inst.handle(self.environ,
                         self.start_response,
                         self.url_map,
                         self.match,
                         self.request_id,
                         instance.SHUTDOWN_REQUEST)))
    self.mox.VerifyAll()

    self.assertEqual(1, inst.total_requests)
    self.assertEqual(1, inst.remaining_request_capacity)
    self.assertEqual(0, inst.num_outstanding_requests)
    self.assertTrue(0 < inst.get_qps_60s())
    self.assertFalse(inst._quitting)
    self.assertTrue(inst._quit)

  def test_handle_shutdown_request_running_request(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=1)
    inst._num_outstanding_requests = 1
    self.mox.StubOutWithMock(inst._condition, 'notify_all')

    self.proxy.start()
    self.environ = {}
    self.request_data.set_request_instance(self.request_id, inst)
    self.proxy.handle(self.environ,
                      self.start_response,
                      self.url_map,
                      self.match,
                      self.request_id,
                      instance.SHUTDOWN_REQUEST).AndReturn(self.response)
    self.mox.ReplayAll()
    inst.start()
    self.assertTrue(inst.can_accept_requests)
    self.assertFalse(inst.has_quit)
    inst.quit(expect_shutdown=True)
    self.assertFalse(inst.can_accept_requests)
    self.assertTrue(inst.has_quit)
    self.assertEqual(
        self.response,
        list(inst.handle(self.environ,
                         self.start_response,
                         self.url_map,
                         self.match,
                         self.request_id,
                         instance.SHUTDOWN_REQUEST)))
    self.mox.VerifyAll()

    self.assertEqual(1, inst.total_requests)
    self.assertEqual(0, inst.remaining_request_capacity)
    self.assertEqual(1, inst.num_outstanding_requests)
    self.assertEqual(0, inst.idle_seconds)
    self.assertTrue(0 < inst.get_qps_60s())
    self.assertTrue(inst._quitting)
    self.assertFalse(inst._quit)

  def test_handle_before_start(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5)
    self.mox.StubOutWithMock(inst._condition, 'notify')

    self.assertRaises(instance.CannotAcceptRequests,
                      inst.handle,
                      self.environ,
                      self.start_response,
                      self.url_map,
                      self.match,
                      self.request_id,
                      instance.NORMAL_REQUEST)

  def test_handle_after_quit(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5)
    self.mox.StubOutWithMock(inst._condition, 'notify')
    self.mox.StubOutWithMock(inst._condition, 'notify_all')

    self.proxy.start()
    self.proxy.quit()
    inst._condition.notify_all()

    self.mox.ReplayAll()
    inst.start()
    inst.quit()

    self.assertRaises(instance.CannotAcceptRequests,
                      inst.handle,
                      self.environ,
                      self.start_response,
                      self.url_map,
                      self.match,
                      self.request_id,
                      instance.NORMAL_REQUEST)
    self.mox.VerifyAll()

  def test_handle_while_quitting(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5)
    self.mox.StubOutWithMock(inst._condition, 'notify')
    inst._num_outstanding_requests = 1

    self.proxy.start()
    self.mox.ReplayAll()
    inst.start()
    inst.quit(allow_async=True)
    self.mox.VerifyAll()

    self.assertRaises(instance.CannotAcceptRequests,
                      inst.handle,
                      self.environ,
                      self.start_response,
                      self.url_map,
                      self.match,
                      self.request_id,
                      instance.NORMAL_REQUEST)

  def test_handle_no_capacity(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=1)
    self.mox.StubOutWithMock(inst._condition, 'notify')
    inst._num_outstanding_requests = 1
    self.proxy.start()
    self.assertRaises(instance.CannotAcceptRequests,
                      inst.handle,
                      self.environ,
                      self.start_response,
                      self.url_map,
                      self.match,
                      self.request_id,
                      instance.NORMAL_REQUEST)

  def test_reserve_background_thread_success(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5,
                             max_background_threads=2)
    inst._started = True

    self.mox.ReplayAll()
    self.assertEqual(2, inst.remaining_background_thread_capacity)
    inst.reserve_background_thread()
    self.assertEqual(1, inst.remaining_background_thread_capacity)
    self.mox.VerifyAll()

  def test_reserve_background_thread_quitting(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5,
                             max_background_threads=2)
    inst._started = True
    inst._quitting = True

    self.mox.ReplayAll()
    self.assertEqual(2, inst.remaining_background_thread_capacity)
    inst.reserve_background_thread()
    self.assertEqual(1, inst.remaining_background_thread_capacity)
    self.mox.VerifyAll()

  def test_reserve_background_thread_no_capacity(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5,
                             max_background_threads=0)
    inst._started = True
    self.mox.ReplayAll()
    self.assertEqual(0, inst.remaining_background_thread_capacity)
    self.assertRaises(instance.CannotAcceptRequests,
                      inst.reserve_background_thread)
    self.mox.VerifyAll()
    self.assertEqual(0, inst.remaining_background_thread_capacity)

  def test_reserve_background_thread_not_started(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5,
                             max_background_threads=1)
    self.mox.ReplayAll()
    self.assertEqual(1, inst.remaining_background_thread_capacity)
    self.assertRaises(instance.CannotAcceptRequests,
                      inst.reserve_background_thread)
    self.mox.VerifyAll()
    self.assertEqual(1, inst.remaining_background_thread_capacity)

  def test_reserve_background_thread_quit(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5,
                             max_background_threads=1)
    inst._started = True
    inst._quit = True
    self.mox.ReplayAll()
    self.assertEqual(1, inst.remaining_background_thread_capacity)
    self.assertRaises(instance.CannotAcceptRequests,
                      inst.reserve_background_thread)
    self.mox.VerifyAll()
    self.assertEqual(1, inst.remaining_background_thread_capacity)

  def test_reserve_background_thread_not_ready(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5,
                             max_background_threads=2,
                             expect_ready_request=True)
    inst._started = True
    self.mox.ReplayAll()
    self.assertEqual(2, inst.remaining_background_thread_capacity)
    inst.reserve_background_thread()
    self.mox.VerifyAll()
    self.assertEqual(1, inst.remaining_background_thread_capacity)

  def test_wait_with_capacity(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=1)
    inst._started = True
    self.mox.StubOutWithMock(inst._condition, 'wait')
    self.mox.stubs.Set(time, 'time', lambda: 0)
    self.mox.ReplayAll()
    self.assertTrue(inst.wait(1))
    self.mox.VerifyAll()

  def test_wait_waiting_for_can_accept(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=1,
                             expect_ready_request=True)
    inst._started = True
    self.mox.StubOutWithMock(inst._condition, 'wait')
    self.time = 0
    self.mox.stubs.Set(time, 'time', lambda: self.time)

    def advance_time(*unused_args):
      self.time += 10

    inst._condition.wait(1).WithSideEffects(advance_time)
    self.mox.ReplayAll()
    self.assertFalse(inst.wait(1))
    self.mox.VerifyAll()

  def test_wait_timed_out_with_capacity(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=1)
    inst._started = True
    self.mox.StubOutWithMock(inst._condition, 'wait')
    self.mox.ReplayAll()
    self.assertTrue(inst.wait(0))
    self.mox.VerifyAll()

  def test_wait_without_capacity(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=0)
    inst._started = True
    self.mox.StubOutWithMock(inst._condition, 'wait')
    self.time = 0
    self.mox.stubs.Set(time, 'time', lambda: self.time)

    def advance_time(*unused_args):
      self.time += 10

    inst._condition.wait(1).WithSideEffects(advance_time)
    self.mox.ReplayAll()
    self.assertFalse(inst.wait(1))
    self.mox.VerifyAll()

  def test_wait_timed_out_without_capacity(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=0)
    inst._started = True
    self.mox.StubOutWithMock(inst._condition, 'wait')
    self.mox.ReplayAll()
    self.assertFalse(inst.wait(0))
    self.mox.VerifyAll()

  def test_wait_quit_while_starting(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5)
    self.mox.StubOutWithMock(inst._condition, 'notify_all')
    self.proxy.start().WithSideEffects(inst.quit)

    self.proxy.quit()

    self.mox.ReplayAll()
    inst.start()
    self.mox.VerifyAll()
    self.assertFalse(inst.can_accept_requests)

  def test_wait_quit_while_waiting(self):
    self.mox.stubs.Set(time, 'time', lambda: 0)
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=0)
    self.mox.StubOutWithMock(inst._condition, 'wait')
    inst._condition.wait(1).WithSideEffects(lambda *unused_args: inst.quit())
    self.mox.ReplayAll()
    self.assertFalse(inst.wait(1))
    self.mox.VerifyAll()

  def test_quit(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5)
    self.mox.StubOutWithMock(inst._condition, 'notify_all')
    self.proxy.start()

    self.proxy.quit()
    inst._condition.notify_all()

    self.mox.ReplayAll()
    inst.start()
    self.assertTrue(inst.can_accept_requests)
    inst.quit()
    self.mox.VerifyAll()
    self.assertFalse(inst.can_accept_requests)

  def test_quit_with_request(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5)
    self.mox.StubOutWithMock(inst._condition, 'notify_all')
    self.proxy.start()

    self.mox.ReplayAll()
    inst.start()
    self.mox.VerifyAll()
    inst._num_outstanding_requests = 1
    self.assertRaises(instance.CannotQuitServingInstance,
                      inst.quit)

  def test_quit_with_request_force(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5)
    self.mox.StubOutWithMock(inst._condition, 'notify_all')

    inst._num_outstanding_requests = 1
    self.proxy.start()
    self.proxy.quit()
    inst._condition.notify_all()

    self.mox.ReplayAll()
    inst.start()
    inst.quit(force=True)
    self.mox.VerifyAll()

  def test_quit_with_request_force_and_allow_async(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5)
    self.mox.StubOutWithMock(inst._condition, 'notify_all')

    inst._num_outstanding_requests = 1
    self.proxy.start()
    self.proxy.quit()
    inst._condition.notify_all()

    self.mox.ReplayAll()
    inst.start()
    inst.quit(force=True, allow_async=True)
    self.mox.VerifyAll()

  def test_quit_with_request_allow_async(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5)
    self.mox.StubOutWithMock(inst._condition, 'notify_all')

    inst._num_outstanding_requests = 1
    self.proxy.start()

    self.mox.ReplayAll()
    inst.start()
    inst.quit(allow_async=True)
    self.mox.VerifyAll()
    self.assertTrue(inst._quitting)

  def test_quit_shutdown(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5)
    self.mox.StubOutWithMock(inst._condition, 'notify_all')

    inst._num_outstanding_requests = 1
    self.proxy.start()

    self.mox.ReplayAll()
    inst.start()
    inst.quit(expect_shutdown=True)
    self.mox.VerifyAll()
    self.assertTrue(inst._expecting_shutdown_request)
    self.assertFalse(inst._quitting)

  def test_get_latency_60s(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5)
    now = time.time()
    inst._request_history = [(now, now+1), (now+2, now+4)]
    self.assertEqual(1.5, inst.get_latency_60s())

  def test_get_qps_60s(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5)
    now = time.time()
    inst._request_history = [(now, now+1)] * 120
    self.assertEqual(2.0, inst.get_qps_60s())

  def test__trim_request_history_to_60s(self):
    inst = instance.Instance(self.request_data, 'name', self.proxy,
                             max_concurrent_requests=5)
    inst._request_history.append((0, 100))
    inst._request_history.append((1.0, 101))
    inst._request_history.append((1.2, 102))
    inst._request_history.append((2.5, 103))

    now = time.time()
    inst._request_history.append((now, 42))
    inst._request_history.append((now + 1, 43))
    inst._request_history.append((now + 3, 44))
    inst._request_history.append((now + 4, 45))

    inst._trim_request_history_to_60s()
    self.assertEqual([(now, 42), (now + 1, 43), (now + 3, 44), (now + 4, 45)],
                     list(inst._request_history))


if __name__ == '__main__':
  unittest.main()
