You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

182 lines
5.4 KiB

  1. from .dbtest import (
  2. DbTest,
  3. dbconnect
  4. )
  5. import os
  6. from psycopg2.extras import (
  7. RealDictCursor,
  8. RealDictRow
  9. )
  10. PATH_TO_SQL_DIR = os.path.abspath(
  11. os.path.join(
  12. os.path.dirname(__file__),
  13. "..",
  14. "sql"
  15. )
  16. )
  17. class TestExample(DbTest):
  18. @dbconnect
  19. def test_select_organizations(self, conn):
  20. self.load_fixtures(
  21. conn,
  22. os.path.join(PATH_TO_SQL_DIR, "organizations.sql")
  23. )
  24. sql = """
  25. SELECT * FROM organizations;
  26. """
  27. with conn.cursor(cursor_factory=RealDictCursor) as cur:
  28. cur.execute(sql)
  29. organizations = cur.fetchall()
  30. assert len(organizations) == 7
  31. @dbconnect
  32. def test_count_the_number_of_subordinates(self, conn):
  33. self.load_fixtures(
  34. conn,
  35. os.path.join(PATH_TO_SQL_DIR, "organizations.sql")
  36. )
  37. sql = """
  38. SELECT
  39. COUNT(customers.*) AS "subordinates_count",
  40. organizations.id AS "id"
  41. FROM organizations
  42. LEFT OUTER JOIN enterprise_sales_enterprise_customers customers ON customers.sales_organization_id = organizations.id
  43. GROUP BY organizations.id
  44. ORDER BY organizations.id ASC
  45. ;
  46. """
  47. with conn.cursor(cursor_factory=RealDictCursor) as cur:
  48. cur.execute(sql)
  49. actual = cur.fetchall()
  50. print(actual)
  51. assert len(actual) == 7
  52. assert actual == [
  53. RealDictRow(**{
  54. "subordinates_count": 0,
  55. "id": 1,
  56. })
  57. , RealDictRow(**{
  58. "subordinates_count": 4,
  59. "id": 2,
  60. })
  61. , RealDictRow(**{
  62. "subordinates_count": 0,
  63. "id": 3,
  64. })
  65. , RealDictRow(**{
  66. "subordinates_count": 0,
  67. "id": 4,
  68. })
  69. , RealDictRow(**{
  70. "subordinates_count": 0,
  71. "id": 5,
  72. })
  73. , RealDictRow(**{
  74. "subordinates_count": 1,
  75. "id": 6,
  76. })
  77. , RealDictRow(**{
  78. "subordinates_count": 0,
  79. "id": 7,
  80. })
  81. ]
  82. @dbconnect
  83. def test_calculate_center_of_each_segment(self, conn):
  84. self.load_fixtures(
  85. conn,
  86. os.path.join(PATH_TO_SQL_DIR, "japan_segments.sql")
  87. )
  88. sql = """
  89. """
  90. with conn.cursor(cursor_factory=RealDictCursor) as cur:
  91. cur.execute(sql)
  92. actual = cur.fetchall()
  93. print(actual)
  94. assert len(actual) == 10
  95. assert actual == [
  96. RealDictRow(**{
  97. "id": "KAGOSHIMA_1",
  98. "longitude": 130.642228315775,
  99. "latitude": 30.7045454545455,
  100. })
  101. , RealDictRow(**{
  102. "id": "KAGOSHIMA_2",
  103. "longitude": 130.694183864916,
  104. "latitude": 30.7045454545455,
  105. })
  106. , RealDictRow(**{
  107. "id": "KAGOSHIMA_3",
  108. "longitude": 130.746139414057,
  109. "latitude": 30.7045454545455,
  110. })
  111. , RealDictRow(**{
  112. "id": "KAGOSHIMA_4",
  113. "longitude": 129.707028431231,
  114. "latitude": 30.75,
  115. })
  116. , RealDictRow(**{
  117. "id": "KAGOSHIMA_5",
  118. "longitude": 129.758983980373,
  119. "latitude": 30.75,
  120. })
  121. , RealDictRow(**{
  122. "id": "KAGOSHIMA_6",
  123. "longitude": 129.810939529514,
  124. "latitude": 30.75,
  125. })
  126. , RealDictRow(**{
  127. "id": "KAGOSHIMA_7",
  128. "longitude": 129.862895078655,
  129. "latitude": 30.75,
  130. })
  131. , RealDictRow(**{
  132. "id": "KAGOSHIMA_8",
  133. "longitude": 129.914850627797,
  134. "latitude": 30.75,
  135. })
  136. , RealDictRow(**{
  137. "id": "KAGOSHIMA_9",
  138. "longitude": 129.966806176937,
  139. "latitude": 30.75,
  140. })
  141. , RealDictRow(**{
  142. "id": "KAGOSHIMA_10",
  143. "longitude": 130.018761726079,
  144. "latitude": 30.75,
  145. })
  146. ]
  147. @dbconnect
  148. def test_segments_using_geojson_boundary(self, conn):
  149. self.load_fixtures(
  150. conn,
  151. os.path.join(PATH_TO_SQL_DIR, "japan_segments.sql")
  152. )
  153. sql = """
  154. """
  155. with conn.cursor(cursor_factory=RealDictCursor) as cur:
  156. cur.execute(sql)
  157. actual = cur.fetchall()
  158. print(actual)
  159. assert len(actual) == 3
  160. assert actual == [
  161. RealDictRow(**{
  162. "id": "KAGOSHIMA_1",
  163. })
  164. , RealDictRow(**{
  165. "id": "KAGOSHIMA_2",
  166. })
  167. , RealDictRow(**{
  168. "id": "KAGOSHIMA_3",
  169. })
  170. ]