More rigid tests of AST classes

Author: Cito

README.md

@@ -16,7 +16,7 @@ The current version 3.0.0a1 of GraphQL-core is up-to-date
 with GraphQL.js version 14.4.0.
 
 All parts of the API are covered by an extensive test suite
-of currently 1891 unit tests.
+of currently 1906 unit tests.
 
 
 ## Documentation

src/graphql/language/ast.py

@@ -91,7 +91,7 @@ def __str__(self):
 
     def __repr__(self):
         """Print a simplified form when appearing in repr() or inspect()."""
-        return f"<Token {self.desc} {self.line}/{self.column}>"
+        return f"<Token {self.desc} {self.line}:{self.column}>"
 
     def __inspect__(self):
         return repr(self)
@@ -168,6 +168,9 @@ def __eq__(self, other):
             return self.start == other[0] and self.end == other[1]
         return False
 
+    def __ne__(self, other):
+        return not self.__eq__(other)
+
     def __hash__(self):
         return hash((self.start, self.end))
 

tests/language/test_ast.py

@@ -1,12 +1,126 @@
-from copy import copy
+from copy import copy, deepcopy
 
-from graphql.language import Node
+from graphql.language import Location, Node, Source, Token, TokenKind
+from graphql.pyutils import inspect
 
 
 class SampleTestNode(Node):
     __slots__ = "alpha", "beta"
 
 
+def describe_token_class():
+    def initializes():
+        prev = Token(TokenKind.EQUALS, 10, 11, 1, 2)
+        token = Token(
+            kind=TokenKind.NAME,
+            start=11,
+            end=12,
+            line=1,
+            column=3,
+            prev=prev,
+            value="n",
+        )
+        assert prev.kind == TokenKind.EQUALS
+        assert prev.start == 10
+        assert prev.end == 11
+        assert prev.line == 1
+        assert prev.column == 2
+        assert token.kind == TokenKind.NAME
+        assert token.start == 11
+        assert token.end == 12
+        assert token.line == 1
+        assert token.column == 3
+        assert token.prev is prev
+        assert token.value == "n"
+
+    def can_stringify():
+        token = Token(TokenKind.NAME, 1, 2, 1, 2, value="test")
+        assert str(token) == "Name 'test'"
+        assert token.desc == str(token)
+
+    def has_representation_with_line_and_column():
+        token = Token(TokenKind.NAME, 1, 2, 1, 2, value="test")
+        assert repr(token) == "<Token Name 'test' 1:2>"
+        assert inspect(token) == repr(token)
+
+    def can_check_equality():
+        token1 = Token(TokenKind.NAME, 1, 2, 1, 2, value="test")
+        token2 = Token(TokenKind.NAME, 1, 2, 1, 2, value="test")
+        assert token2 == token1
+        assert not token2 != token1
+        token3 = Token(TokenKind.NAME, 1, 2, 1, 2, value="text")
+        assert token3 != token1
+        token4 = Token(TokenKind.NAME, 1, 4, 1, 2, value="test")
+        assert token4 != token1
+        token5 = Token(TokenKind.NAME, 1, 2, 1, 4, value="test")
+        assert token5 != token1
+
+    def can_hash():
+        token1 = Token(TokenKind.NAME, 1, 2, 1, 2, value="hash")
+        token2 = Token(TokenKind.NAME, 1, 2, 1, 2, value="hash")
+        assert token2 == token1
+        assert hash(token2) == hash(token1)
+        token3 = Token(TokenKind.NAME, 1, 2, 1, 2, value="bash")
+        assert token3 != token1
+        assert hash(token3) != hash(token1)
+
+    def can_copy():
+        token1 = Token(TokenKind.NAME, 1, 2, 1, 2, value="copy")
+        token2 = copy(token1)
+        assert token2 == token1
+        assert token2 is not token1
+
+
+def describe_location_class():
+    token1 = Token(TokenKind.NAME, 1, 2, 1, 2)
+    token2 = Token(TokenKind.NAME, 2, 3, 1, 3)
+    source = Source("source")
+
+    def initializes():
+        loc = Location(1, 2, token1, token2, source)
+        assert loc.start == 1
+        assert loc.end == 2
+        assert loc.start_token is token1
+        assert loc.end_token is token2
+        assert loc.source is source
+
+    def can_stringify_with_start_and_end():
+        loc = Location(1, 2, token1, token2, source)
+        assert str(loc) == "1:2"
+
+    def has_representation_with_start_and_end():
+        loc = Location(1, 2, token1, token2, source)
+        assert repr(loc) == "<Location 1:2>"
+        assert inspect(loc) == repr(loc)
+
+    def can_check_equality():
+        loc1 = Location(1, 2, token1, token2, source)
+        loc2 = Location(1, 2, token1, token2, source)
+        assert loc2 == loc1
+        loc3 = Location(3, 2, token1, token2, source)
+        assert loc3 != loc1
+        loc4 = Location(1, 4, token1, token2, source)
+        assert loc4 != loc1
+
+    def can_check_equality_with_tuple_or_list():
+        loc = Location(1, 2, token1, token2, source)
+        assert loc == (1, 2)
+        assert loc == [1, 2]
+        assert not loc != (1, 2)
+        assert not loc != [1, 2]
+        assert loc != (3, 2)
+        assert loc != [1, 4]
+
+    def can_hash():
+        loc1 = Location(1, 2, token1, token2, source)
+        loc2 = Location(1, 2, token1, token2, source)
+        assert loc2 == loc1
+        assert hash(loc2) == hash(loc1)
+        loc3 = Location(1, 3, token1, token2, source)
+        assert loc3 != loc1
+        assert hash(loc3) != hash(loc1)
+
+
 def describe_node_class():
     def initializes_with_keywords():
         node = SampleTestNode(alpha=1, beta=2, loc=0)
@@ -32,17 +146,49 @@ def can_check_equality():
         node = SampleTestNode(alpha=1, beta=2)
         node2 = SampleTestNode(alpha=1, beta=2)
         assert node2 == node
+        assert not node2 != node
         node2 = SampleTestNode(alpha=1, beta=1)
         assert node2 != node
         node2 = Node(alpha=1, beta=2)
         assert node2 != node
 
+    def can_hash():
+        node = SampleTestNode(alpha=1, beta=2)
+        node2 = SampleTestNode(alpha=1, beta=2)
+        assert node == node2
+        assert node2 is not node
+        assert hash(node2) == hash(node)
+        node3 = SampleTestNode(alpha=1, beta=3)
+        assert node3 != node
+        assert hash(node3) != hash(node)
+
     def can_create_shallow_copy():
         node = SampleTestNode(alpha=1, beta=2)
         node2 = copy(node)
         assert node2 is not node
         assert node2 == node
 
+    def shallow_copy_is_really_shallow():
+        node = SampleTestNode(alpha=1, beta=2)
+        node2 = SampleTestNode(alpha=node, beta=node)
+        node3 = copy(node2)
+        assert node3 is not node2
+        assert node3 == node2
+        assert node3.alpha is node2.alpha
+        assert node3.beta is node2.beta
+
+    def can_create_deep_copy():
+        alpha = SampleTestNode(alpha=1, beta=2)
+        beta = SampleTestNode(alpha=3, beta=4)
+        node = SampleTestNode(alpha=alpha, beta=beta)
+        node2 = deepcopy(node)
+        assert node2 is not node
+        assert node2 == node
+        assert node2.alpha == alpha
+        assert node2.alpha is not alpha
+        assert node2.alpha == alpha
+        assert node2.beta is not beta
+
     def provides_snake_cased_kind_as_class_attribute():
         assert SampleTestNode.kind == "sample_test"
 

tests/language/test_lexer.py

@@ -45,7 +45,7 @@ def can_be_stringified_or_pyutils_inspected():
         token = lex_one("foo")
         assert token.desc == "Name 'foo'"
         assert str(token) == token.desc
-        assert repr(token) == "<Token Name 'foo' 1/1>"
+        assert repr(token) == "<Token Name 'foo' 1:1>"
         assert inspect(token) == repr(token)
 
     # noinspection PyArgumentEqualDefault