make Schema.__eq__ deterministic

voluptuous/schema_builder.py

@@ -242,10 +242,12 @@ def value_to_schema_type(value):
         return cls(value_to_schema_type(data), **kwargs)
 
     def __eq__(self, other):
-        if str(other) == str(self.schema):
-            # Because repr is combination mixture of object and schema
-            return True
-        return False
+        if not isinstance(other, Schema):
+            return False
+        return other.schema == self.schema
+
+    def __ne__(self, other):
+        return not (self == other)
 
     def __str__(self):
         return str(self.schema)

voluptuous/tests/tests.py

@@ -3,7 +3,7 @@
 import os
 import sys
 
-from nose.tools import assert_equal, assert_raises, assert_true
+from nose.tools import assert_equal, assert_false, assert_raises, assert_true
 
 from voluptuous import (
     Schema, Required, Exclusive, Optional, Extra, Invalid, In, Remove, Literal,
@@ -410,6 +410,69 @@ def test_subschema_extension():
     assert_equal(extended.schema, {'a': {'b': str, 'c': float, 'e': int}, 'd': str})
 
 
+def test_equality():
+    assert_equal(Schema('foo'), Schema('foo'))
+
+    assert_equal(Schema(['foo', 'bar', 'baz']),
+                 Schema(['foo', 'bar', 'baz']))
+
+    # Ensure two Schemas w/ two equivalent dicts initialized in a different
+    # order are considered equal.
+    dict_a = {}
+    dict_a['foo'] = 1
+    dict_a['bar'] = 2
+    dict_a['baz'] = 3
+
+    dict_b = {}
+    dict_b['baz'] = 3
+    dict_b['bar'] = 2
+    dict_b['foo'] = 1
+
+    assert_equal(Schema(dict_a), Schema(dict_b))
+
+
+def test_equality_negative():
+    """Verify that Schema objects are not equal to string representations"""
+    assert_false(Schema('foo') == 'foo')
+
+    assert_false(Schema(['foo', 'bar']) == "['foo', 'bar']")
+    assert_false(Schema(['foo', 'bar']) == Schema("['foo', 'bar']"))
+
+    assert_false(Schema({'foo': 1, 'bar': 2}) == "{'foo': 1, 'bar': 2}")
+    assert_false(Schema({'foo': 1, 'bar': 2}) == Schema("{'foo': 1, 'bar': 2}"))
+
+
+def test_inequality():
+    assert_true(Schema('foo') != 'foo')
+
+    assert_true(Schema(['foo', 'bar']) != "['foo', 'bar']")
+    assert_true(Schema(['foo', 'bar']) != Schema("['foo', 'bar']"))
+
+    assert_true(Schema({'foo': 1, 'bar': 2}) != "{'foo': 1, 'bar': 2}")
+    assert_true(Schema({'foo': 1, 'bar': 2}) != Schema("{'foo': 1, 'bar': 2}"))
+
+
+def test_inequality_negative():
+    assert_false(Schema('foo') != Schema('foo'))
+
+    assert_false(Schema(['foo', 'bar', 'baz']) !=
+                 Schema(['foo', 'bar', 'baz']))
+
+    # Ensure two Schemas w/ two equivalent dicts initialized in a different
+    # order are considered equal.
+    dict_a = {}
+    dict_a['foo'] = 1
+    dict_a['bar'] = 2
+    dict_a['baz'] = 3
+
+    dict_b = {}
+    dict_b['baz'] = 3
+    dict_b['bar'] = 2
+    dict_b['foo'] = 1
+
+    assert_false(Schema(dict_a) != Schema(dict_b))
+
+
 def test_repr():
     """Verify that __repr__ returns valid Python expressions"""
     match = Match('a pattern', msg='message')