#!/usr/bin/python2.4

#

# Unit tests for Mox.

#

# Copyright 2008 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.

import cStringIO

import unittest

import re

import mox

import mox_test_helper

class ExpectedMethodCallsErrorTest(unittest.TestCase):

  """Test creation and string conversion of ExpectedMethodCallsError."""

  def testAtLeastOneMethod(self):

    self.assertRaises(ValueError, mox.ExpectedMethodCallsError, [])

  def testOneError(self):

    method = mox.MockMethod("testMethod", [], False)

    method(1, 2).AndReturn('output')

    e = mox.ExpectedMethodCallsError([method])

    self.assertEqual(

        "Verify: Expected methods never called:\n"

        "  0.  testMethod(1, 2) -> 'output'",

        str(e))

  def testManyErrors(self):

    method1 = mox.MockMethod("testMethod", [], False)

    method1(1, 2).AndReturn('output')

    method2 = mox.MockMethod("testMethod", [], False)

    method2(a=1, b=2, c="only named")

    method3 = mox.MockMethod("testMethod2", [], False)

    method3().AndReturn(44)

    method4 = mox.MockMethod("testMethod", [], False)

    method4(1, 2).AndReturn('output')

    e = mox.ExpectedMethodCallsError([method1, method2, method3, method4])

    self.assertEqual(

        "Verify: Expected methods never called:\n"

        "  0.  testMethod(1, 2) -> 'output'\n"

        "  1.  testMethod(a=1, b=2, c='only named') -> None\n"

        "  2.  testMethod2() -> 44\n"

        "  3.  testMethod(1, 2) -> 'output'",

        str(e))

class OrTest(unittest.TestCase):

  """Test Or correctly chains Comparators."""

  def testValidOr(self):

    """Or should be True if either Comparator returns True."""

    self.assert_(mox.Or(mox.IsA(dict), mox.IsA(str)) == {})

    self.assert_(mox.Or(mox.IsA(dict), mox.IsA(str)) == 'test')

    self.assert_(mox.Or(mox.IsA(str), mox.IsA(str)) == 'test')

  def testInvalidOr(self):

    """Or should be False if both Comparators return False."""

    self.failIf(mox.Or(mox.IsA(dict), mox.IsA(str)) == 0)

class AndTest(unittest.TestCase):

  """Test And correctly chains Comparators."""

  def testValidAnd(self):

    """And should be True if both Comparators return True."""

    self.assert_(mox.And(mox.IsA(str), mox.IsA(str)) == '1')

  def testClauseOneFails(self):

    """And should be False if the first Comparator returns False."""

    self.failIf(mox.And(mox.IsA(dict), mox.IsA(str)) == '1')

  def testAdvancedUsage(self):

    """And should work with other Comparators.

    Note: this test is reliant on In and ContainsKeyValue.

    """

    test_dict = {"mock" : "obj", "testing" : "isCOOL"}

    self.assert_(mox.And(mox.In("testing"),

                           mox.ContainsKeyValue("mock", "obj")) == test_dict)

  def testAdvancedUsageFails(self):

    """Note: this test is reliant on In and ContainsKeyValue."""

    test_dict = {"mock" : "obj", "testing" : "isCOOL"}

    self.failIf(mox.And(mox.In("NOTFOUND"),

                          mox.ContainsKeyValue("mock", "obj")) == test_dict)

class SameElementsAsTest(unittest.TestCase):

  """Test SameElementsAs correctly identifies sequences with same elements."""

  def testSortedLists(self):

    """Should return True if two lists are exactly equal."""

    self.assert_(mox.SameElementsAs([1, 2.0, 'c']) == [1, 2.0, 'c'])

  def testUnsortedLists(self):

    """Should return True if two lists are unequal but have same elements."""

    self.assert_(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c', 1])

  def testUnhashableLists(self):

    """Should return True if two lists have the same unhashable elements."""

    self.assert_(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) ==

                 [{2: 'b'}, {'a': 1}])

  def testEmptyLists(self):

    """Should return True for two empty lists."""

    self.assert_(mox.SameElementsAs([]) == [])

  def testUnequalLists(self):

    """Should return False if the lists are not equal."""

    self.failIf(mox.SameElementsAs([1, 2.0, 'c']) == [2.0, 'c'])

  def testUnequalUnhashableLists(self):

    """Should return False if two lists with unhashable elements are unequal."""

    self.failIf(mox.SameElementsAs([{'a': 1}, {2: 'b'}]) == [{2: 'b'}])

class ContainsKeyValueTest(unittest.TestCase):

  """Test ContainsKeyValue correctly identifies key/value pairs in a dict.

  """

  def testValidPair(self):

    """Should return True if the key value is in the dict."""

    self.assert_(mox.ContainsKeyValue("key", 1) == {"key": 1})

  def testInvalidValue(self):

    """Should return False if the value is not correct."""

    self.failIf(mox.ContainsKeyValue("key", 1) == {"key": 2})

  def testInvalidKey(self):

    """Should return False if they key is not in the dict."""

    self.failIf(mox.ContainsKeyValue("qux", 1) == {"key": 2})

class InTest(unittest.TestCase):

  """Test In correctly identifies a key in a list/dict"""

  def testItemInList(self):

    """Should return True if the item is in the list."""

    self.assert_(mox.In(1) == [1, 2, 3])

  def testKeyInDict(self):

    """Should return True if the item is a key in a dict."""

    self.assert_(mox.In("test") == {"test" : "module"})

class NotTest(unittest.TestCase):

  """Test Not correctly identifies False predicates."""

  def testItemInList(self):

    """Should return True if the item is NOT in the list."""

    self.assert_(mox.Not(mox.In(42)) == [1, 2, 3])

  def testKeyInDict(self):

    """Should return True if the item is NOT a key in a dict."""

    self.assert_(mox.Not(mox.In("foo")) == {"key" : 42})

  def testInvalidKeyWithNot(self):

    """Should return False if they key is NOT in the dict."""

    self.assert_(mox.Not(mox.ContainsKeyValue("qux", 1)) == {"key": 2})

class StrContainsTest(unittest.TestCase):

  """Test StrContains correctly checks for substring occurrence of a parameter.

  """

  def testValidSubstringAtStart(self):

    """Should return True if the substring is at the start of the string."""

    self.assert_(mox.StrContains("hello") == "hello world")

  def testValidSubstringInMiddle(self):

    """Should return True if the substring is in the middle of the string."""

    self.assert_(mox.StrContains("lo wo") == "hello world")

  def testValidSubstringAtEnd(self):

    """Should return True if the substring is at the end of the string."""

    self.assert_(mox.StrContains("ld") == "hello world")

  def testInvaildSubstring(self):

    """Should return False if the substring is not in the string."""

    self.failIf(mox.StrContains("AAA") == "hello world")

  def testMultipleMatches(self):

    """Should return True if there are multiple occurances of substring."""

    self.assert_(mox.StrContains("abc") == "ababcabcabcababc")

class RegexTest(unittest.TestCase):

  """Test Regex correctly matches regular expressions."""

  def testIdentifyBadSyntaxDuringInit(self):

    """The user should know immediately if a regex has bad syntax."""

    self.assertRaises(re.error, mox.Regex, '(a|b')

  def testPatternInMiddle(self):

    """Should return True if the pattern matches at the middle of the string.

    This ensures that re.search is used (instead of re.find).

    """

    self.assert_(mox.Regex(r"a\s+b") == "x y z a b c")

  def testNonMatchPattern(self):

    """Should return False if the pattern does not match the string."""

    self.failIf(mox.Regex(r"a\s+b") == "x y z")

  def testFlagsPassedCorrectly(self):

    """Should return True as we pass IGNORECASE flag."""

    self.assert_(mox.Regex(r"A", re.IGNORECASE) == "a")

  def testReprWithoutFlags(self):

    """repr should return the regular expression pattern."""

    self.assert_(repr(mox.Regex(r"a\s+b")) == "<regular expression 'a\s+b'>")

  def testReprWithFlags(self):

    """repr should return the regular expression pattern and flags."""

    self.assert_(repr(mox.Regex(r"a\s+b", flags=4)) ==

                 "<regular expression 'a\s+b', flags=4>")

class IsATest(unittest.TestCase):

  """Verify IsA correctly checks equality based upon class type, not value."""

  def testEqualityValid(self):

    """Verify that == correctly identifies objects of the same type."""

    self.assert_(mox.IsA(str) == 'test')

  def testEqualityInvalid(self):

    """Verify that == correctly identifies objects of different types."""

    self.failIf(mox.IsA(str) == 10)

  def testInequalityValid(self):

    """Verify that != identifies objects of different type."""

    self.assert_(mox.IsA(str) != 10)

  def testInequalityInvalid(self):

    """Verify that != correctly identifies objects of the same type."""

    self.failIf(mox.IsA(str) != "test")

  def testEqualityInListValid(self):

    """Verify list contents are properly compared."""

    isa_list = [mox.IsA(str), mox.IsA(str)]

    str_list = ["abc", "def"]

    self.assert_(isa_list == str_list)

  def testEquailtyInListInvalid(self):

    """Verify list contents are properly compared."""

    isa_list = [mox.IsA(str),mox.IsA(str)]

    mixed_list = ["abc", 123]

    self.failIf(isa_list == mixed_list)

  def testSpecialTypes(self):

    """Verify that IsA can handle objects like cStringIO.StringIO."""

    isA = mox.IsA(cStringIO.StringIO())

    stringIO = cStringIO.StringIO()

    self.assert_(isA == stringIO)

class IsAlmostTest(unittest.TestCase):

  """Verify IsAlmost correctly checks equality of floating point numbers."""

  def testEqualityValid(self):

    """Verify that == correctly identifies nearly equivalent floats."""

    self.assertEquals(mox.IsAlmost(1.8999999999), 1.9)

  def testEqualityInvalid(self):

    """Verify that == correctly identifies non-equivalent floats."""

    self.assertNotEquals(mox.IsAlmost(1.899), 1.9)

  def testEqualityWithPlaces(self):

    """Verify that specifying places has the desired effect."""

    self.assertNotEquals(mox.IsAlmost(1.899), 1.9)

    self.assertEquals(mox.IsAlmost(1.899, places=2), 1.9)

  def testNonNumericTypes(self):

    """Verify that IsAlmost handles non-numeric types properly."""

    self.assertNotEquals(mox.IsAlmost(1.8999999999), '1.9')

    self.assertNotEquals(mox.IsAlmost('1.8999999999'), 1.9)

    self.assertNotEquals(mox.IsAlmost('1.8999999999'), '1.9')

class MockMethodTest(unittest.TestCase):

  """Test class to verify that the MockMethod class is working correctly."""

  def setUp(self):

    self.expected_method = mox.MockMethod("testMethod", [], False)(['original'])

    self.mock_method = mox.MockMethod("testMethod", [self.expected_method],

                                        True)

  def testAndReturnNoneByDefault(self):

    """Should return None by default."""

    return_value = self.mock_method(['original'])

    self.assert_(return_value == None)

  def testAndReturnValue(self):

    """Should return a specificed return value."""

    expected_return_value = "test"

    self.expected_method.AndReturn(expected_return_value)

    return_value = self.mock_method(['original'])

    self.assert_(return_value == expected_return_value)

  def testAndRaiseException(self):

    """Should raise a specified exception."""

    expected_exception = Exception('test exception')

    self.expected_method.AndRaise(expected_exception)

    self.assertRaises(Exception, self.mock_method)

  def testWithSideEffects(self):

    """Should call state modifier."""

    local_list = ['original']

    def modifier(mutable_list):

      self.assertTrue(local_list is mutable_list)

      mutable_list[0] = 'mutation'

    self.expected_method.WithSideEffects(modifier).AndReturn(1)

    self.mock_method(local_list)

    self.assertEquals('mutation', local_list[0])

  def testEqualityNoParamsEqual(self):

    """Methods with the same name and without params should be equal."""

    expected_method = mox.MockMethod("testMethod", [], False)

    self.assertEqual(self.mock_method, expected_method)

  def testEqualityNoParamsNotEqual(self):

    """Methods with different names and without params should not be equal."""

    expected_method = mox.MockMethod("otherMethod", [], False)

    self.failIfEqual(self.mock_method, expected_method)

  def testEqualityParamsEqual(self):

    """Methods with the same name and parameters should be equal."""

    params = [1, 2, 3]

    expected_method = mox.MockMethod("testMethod", [], False)

    expected_method._params = params

    self.mock_method._params = params

    self.assertEqual(self.mock_method, expected_method)

  def testEqualityParamsNotEqual(self):

    """Methods with the same name and different params should not be equal."""

    expected_method = mox.MockMethod("testMethod", [], False)

    expected_method._params = [1, 2, 3]

    self.mock_method._params = ['a', 'b', 'c']

    self.failIfEqual(self.mock_method, expected_method)

  def testEqualityNamedParamsEqual(self):

    """Methods with the same name and same named params should be equal."""

    named_params = {"input1": "test", "input2": "params"}

    expected_method = mox.MockMethod("testMethod", [], False)

    expected_method._named_params = named_params

    self.mock_method._named_params = named_params

    self.assertEqual(self.mock_method, expected_method)

  def testEqualityNamedParamsNotEqual(self):

    """Methods with the same name and diffnamed params should not be equal."""

    expected_method = mox.MockMethod("testMethod", [], False)

    expected_method._named_params = {"input1": "test", "input2": "params"}

    self.mock_method._named_params = {"input1": "test2", "input2": "params2"}

    self.failIfEqual(self.mock_method, expected_method)

  def testEqualityWrongType(self):

    """Method should not be equal to an object of a different type."""

    self.failIfEqual(self.mock_method, "string?")

  def testObjectEquality(self):

    """Equality of objects should work without a Comparator"""

    instA = TestClass();

    instB = TestClass();

    params = [instA, ]

    expected_method = mox.MockMethod("testMethod", [], False)

    expected_method._params = params

    self.mock_method._params = [instB, ]

    self.assertEqual(self.mock_method, expected_method)

  def testStrConversion(self):

    method = mox.MockMethod("f", [], False)

    method(1, 2, "st", n1=8, n2="st2")

    self.assertEqual(str(method), ("f(1, 2, 'st', n1=8, n2='st2') -> None"))

    method = mox.MockMethod("testMethod", [], False)

    method(1, 2, "only positional")

    self.assertEqual(str(method), "testMethod(1, 2, 'only positional') -> None")

    method = mox.MockMethod("testMethod", [], False)

    method(a=1, b=2, c="only named")

    self.assertEqual(str(method),

                     "testMethod(a=1, b=2, c='only named') -> None")

    method = mox.MockMethod("testMethod", [], False)

    method()

    self.assertEqual(str(method), "testMethod() -> None")

    method = mox.MockMethod("testMethod", [], False)

    method(x="only 1 parameter")

    self.assertEqual(str(method), "testMethod(x='only 1 parameter') -> None")

    method = mox.MockMethod("testMethod", [], False)

    method().AndReturn('return_value')

    self.assertEqual(str(method), "testMethod() -> 'return_value'")

    method = mox.MockMethod("testMethod", [], False)

    method().AndReturn(('a', {1: 2}))

    self.assertEqual(str(method), "testMethod() -> ('a', {1: 2})")

class MockAnythingTest(unittest.TestCase):

  """Verify that the MockAnything class works as expected."""

  def setUp(self):

    self.mock_object = mox.MockAnything()

  def testSetupMode(self):

    """Verify the mock will accept any call."""

    self.mock_object.NonsenseCall()

    self.assert_(len(self.mock_object._expected_calls_queue) == 1)

  def testReplayWithExpectedCall(self):

    """Verify the mock replays method calls as expected."""

    self.mock_object.ValidCall()          # setup method call

    self.mock_object._Replay()            # start replay mode

    self.mock_object.ValidCall()          # make method call

  def testReplayWithUnexpectedCall(self):

    """Unexpected method calls should raise UnexpectedMethodCallError."""

    self.mock_object.ValidCall()          # setup method call

    self.mock_object._Replay()             # start replay mode

    self.assertRaises(mox.UnexpectedMethodCallError,

                      self.mock_object.OtherValidCall)

  def testVerifyWithCompleteReplay(self):

    """Verify should not raise an exception for a valid replay."""

    self.mock_object.ValidCall()          # setup method call

    self.mock_object._Replay()             # start replay mode

    self.mock_object.ValidCall()          # make method call

    self.mock_object._Verify()

  def testVerifyWithIncompleteReplay(self):

    """Verify should raise an exception if the replay was not complete."""

    self.mock_object.ValidCall()          # setup method call

    self.mock_object._Replay()             # start replay mode

    # ValidCall() is never made

    self.assertRaises(mox.ExpectedMethodCallsError, self.mock_object._Verify)

  def testSpecialClassMethod(self):

    """Verify should not raise an exception when special methods are used."""

    self.mock_object[1].AndReturn(True)

    self.mock_object._Replay()

    returned_val = self.mock_object[1]

    self.assert_(returned_val)

    self.mock_object._Verify()

  def testNonzero(self):

    """You should be able to use the mock object in an if."""

    self.mock_object._Replay()

    if self.mock_object:

      pass

  def testNotNone(self):

    """Mock should be comparable to None."""

    self.mock_object._Replay()

    if self.mock_object is not None:

      pass

    if self.mock_object is None:

      pass

  def testEquals(self):

    """A mock should be able to compare itself to another object."""

    self.mock_object._Replay()

    self.assertEquals(self.mock_object, self.mock_object)

  def testEqualsMockFailure(self):

    """Verify equals identifies unequal objects."""

    self.mock_object.SillyCall()

    self.mock_object._Replay()

    self.assertNotEquals(self.mock_object, mox.MockAnything())

  def testEqualsInstanceFailure(self):

    """Verify equals identifies that objects are different instances."""

    self.mock_object._Replay()

    self.assertNotEquals(self.mock_object, TestClass())

  def testNotEquals(self):

    """Verify not equals works."""

    self.mock_object._Replay()

    self.assertFalse(self.mock_object != self.mock_object)

  def testNestedMockCallsRecordedSerially(self):

    """Test that nested calls work when recorded serially."""

    self.mock_object.CallInner().AndReturn(1)

    self.mock_object.CallOuter(1)

    self.mock_object._Replay()

    self.mock_object.CallOuter(self.mock_object.CallInner())

    self.mock_object._Verify()

  def testNestedMockCallsRecordedNested(self):

    """Test that nested cals work when recorded in a nested fashion."""

    self.mock_object.CallOuter(self.mock_object.CallInner().AndReturn(1))

    self.mock_object._Replay()

    self.mock_object.CallOuter(self.mock_object.CallInner())

    self.mock_object._Verify()

  def testIsCallable(self):

    """Test that MockAnything can even mock a simple callable.

    This is handy for "stubbing out" a method in a module with a mock, and

    verifying that it was called.

    """

    self.mock_object().AndReturn('mox0rd')