Enable logs v2 api (#95)

Author: api-clients-generation-pipeline[bot]

.apigentools-info

@@ -4,13 +4,13 @@
     "spec_versions": {
         "v1": {
             "apigentools_version": "1.2.0",
-            "regenerated": "2020-09-30 11:19:01.491807",
-            "spec_repo_commit": "cbeec4e"
+            "regenerated": "2020-09-30 14:11:12.314239",
+            "spec_repo_commit": "8738cfd"
         },
         "v2": {
             "apigentools_version": "1.2.0",
-            "regenerated": "2020-09-30 11:19:13.143953",
-            "spec_repo_commit": "cbeec4e"
+            "regenerated": "2020-09-30 14:11:22.976815",
+            "spec_repo_commit": "8738cfd"
         }
     }
 }

setup.cfg

@@ -56,7 +56,7 @@ tests =
     freezegun
     jinja2
     pytest
-    pytest-bdd==3.4.0
+    pytest-bdd>=4.0.1
     pytest-black
     pytest-cov
     pytest-randomly

tests/conftest.py

@@ -1,19 +1,22 @@
 # coding=utf-8
 """Define basic fixtures."""
 
+import os
+
 # First patch httplib
-try:
-    from ddtrace import config, patch, tracer
+tracer = None
+if "false" != os.getenv("RECORD", "false"):
+    try:
+        from ddtrace import config, patch, tracer
 
-    config.httplib["distributed_tracing"] = True
-    patch(httplib=True)
-except ImportError:
-    tracer = None
+        config.httplib["distributed_tracing"] = True
+        patch(httplib=True)
+    except ImportError:
+        pass
 
 import importlib
 import json
 import logging
-import os
 import re
 import sys
 import time
@@ -123,7 +126,10 @@ def pytest_bdd_apply_tag(tag, function):
 
 def snake_case(value):
     s1 = re.sub("(.)([A-Z][a-z]+)", r"\1_\2", value)
-    return re.sub("([a-z0-9])([A-Z])", r"\1_\2", s1).lower()
+    s1 = re.sub("([a-z0-9])([A-Z])", r"\1_\2", s1).lower()
+    s1 = re.sub(r"\W", "_", s1)
+    s1 = re.sub(r"_+$", "", s1)
+    return re.sub(r"__+", "_", s1)
 
 
 def glom(value, path):
@@ -173,17 +179,28 @@ def __str__(self):
 
 
 @pytest.fixture
-def fixtures(request, unique, unique_lower):
-    """Return a mapping with all defined fixtures."""
-    ctx = {}
+def context(vcr_cassette, request, unique, unique_lower):
+    """
+    Return a mapping with all defined fixtures, all objects created by `given` steps,
+    and the undo operations to perform after a test scenario.
+    """
+    ctx = {"undo_operations": []}
     for f in request.fixturenames:
-        if f == "fixtures":
+        if f == "context":
             continue
         try:
             ctx[f] = request.getfixturevalue(f)
         except Exception:
             pass
-    return ctx
+    yield ctx
+    for undo in reversed(ctx["undo_operations"]):
+        if vcr_cassette.record_mode != "none":
+            number_of_interactions = len(vcr_cassette.data)
+            try:
+                undo()
+            except Exception as e:
+                warnings.warn(str(e))
+            vcr_cassette.data = vcr_cassette.data[:number_of_interactions]
 
 
 @pytest.fixture(scope="module", autouse=True)
@@ -226,10 +243,11 @@ def freezer(vcr_cassette_name, vcr_cassette, vcr):
     if vcr_cassette.record_mode != "none":
         tzinfo = datetime.now().astimezone().tzinfo
         freeze_at = datetime.now().replace(tzinfo=tzinfo).isoformat()
-        with open(
-            os.path.join(vcr.cassette_library_dir, vcr_cassette_name + ".frozen"), "w+",
-        ) as f:
-            f.write(freeze_at)
+        if vcr_cassette.record_mode == "all":
+            with open(
+                os.path.join(vcr.cassette_library_dir, vcr_cassette_name + ".frozen"), "w+",
+            ) as f:
+                f.write(freeze_at)
     else:
         with open(
             os.path.join(vcr.cassette_library_dir, vcr_cassette_name + ".frozen"), "r",
@@ -276,25 +294,27 @@ def client(_package, configuration, record_mode, vcr_cassette):
 
 
 @given(parsers.parse('an instance of "{name}" API'))
-def api(package_name, client, name):
+def api(context, package_name, client, name):
     """Return an API instance."""
     module_name = snake_case(name)
     package = importlib.import_module(f"{package_name}.api.{module_name}_api")
-    return {
+    context["api"] = {
         "api": getattr(package, name + "Api")(client),
         "calls": [],
     }
 
+
 @given(parsers.parse('operation "{name}" enabled'))
 def operation_enabled(client, name):
     """Enable the unstable operation specific in the clause."""
     client.configuration.unstable_operations[snake_case(name)] = True
 
 
 @given(parsers.parse('new "{name}" request'))
-def api_request(api, name):
+def api_request(context, name):
     """Call an endpoint."""
-    return {
+    api = context["api"]
+    context["api_request"] = {
         "api": api["api"],
         "request": getattr(api["api"], snake_case(name)),
         "args": [],
@@ -312,22 +332,29 @@ def api_request(api, name):
 
 
 @given(parsers.parse("body {data}"))
-def request_body(fixtures, api_request, data):
+def request_body(context, data):
     """Set request body."""
     import json
     from jinja2 import Template
 
-    tpl = Template(data).render(**fixtures)
-    body = api_request["kwargs"]["body"] = json.loads(tpl)
-
-    return body
+    tpl = Template(data).render(**context)
+    context["api_request"]["kwargs"]["body"] = json.loads(tpl)
 
 
 @given(parsers.parse('request contains "{name}" parameter from "{path}"'))
-def request_parameter(fixtures, api_request, name, path):
+def request_parameter(context, name, path):
     """Set request parameter."""
-    api_request["kwargs"][name] = parameter = glom(fixtures, path)
-    return parameter
+    context["api_request"]["kwargs"][snake_case(name)] = glom(context, path)
+
+
+@given(parsers.parse('request contains "{name}" parameter with value {value}'))
+def request_parameter_with_value(context, name, value):
+    """Set request parameter."""
+    import json
+    from jinja2 import Template
+
+    tpl = Template(value).render(**context)
+    context["api_request"]["kwargs"][snake_case(name)] = json.loads(tpl)
 
 
 def undo(api_request, client):
@@ -343,16 +370,24 @@ def undo(api_request, client):
     elif operation_id == "create_team":
         client.configuration.unstable_operations["delete_team"] = True
         return api_request["api"].delete_team(api_request["response"][0].data.id)
-    elif operation_id in {"update_user", "add_permission_to_role", "add_user_to_role", "send_invitations"}:
+    elif operation_id in {
+        "update_user",
+        "add_permission_to_role",
+        "add_user_to_role",
+        "send_invitations",
+        "aggregate_logs",
+        "list_logs",
+    }:
         return
     elif api_request["request"].settings["http_method"] == "PATCH":
         return
     raise NotImplementedError(operation_id)
 
 
 @when("the request is sent")
-def execute_request(vcr_cassette, api_request, client):
+def execute_request(context, vcr_cassette, client):
     """Execute the prepared request."""
+    api_request = context["api_request"]
     api_request["response"] = api_request["request"].call_with_http_info(
         *api_request["args"], **api_request["kwargs"]
     )
@@ -369,41 +404,41 @@ def execute_request(vcr_cassette, api_request, client):
 
 
 @then(parsers.parse('I should get an instance of "{name}"'))
-def i_should_get_an_instace_of(package_name, api, name):
+def i_should_get_an_instace_of(context, package_name, name):
     """I should get an instace."""
     module_name = snake_case(name)
     package = importlib.import_module(f"{package_name}.model.{module_name}")
-    assert isinstance(api_request["response"][0], getattr(package, name))
+    assert isinstance(context["api_request"]["response"][0], getattr(package, name))
 
 
 @then(parsers.parse('I should get a list of "{name}" objects'))
-def i_should_get_a_list_of_objects(package_name, api, name):
+def i_should_get_a_list_of_objects(context, package_name, name):
     """I should get an instace."""
     module_name = snake_case(name)
     package = importlib.import_module(f"{package_name}.model.{module_name}")
     cls = getattr(package, name)
-    assert all(isinstance(obj, cls) for obj in api_request["response"][0])
+    assert all(isinstance(obj, cls) for obj in context["api_request"]["response"][0])
 
 
 @then(parsers.parse("the response status is {status:d} {description}"))
-def the_status_is(api_request, status, description):
+def the_status_is(context, status, description):
     """Check the status."""
-    assert status == api_request["response"][1]
+    assert status == context["api_request"]["response"][1]
 
 
 @then(parsers.parse('the response "{response_path}" is equal to {value}'))
-def expect_equal(api_request, fixtures, response_path, value):
+def expect_equal(context, response_path, value):
     from jinja2 import Template
 
-    response_value = glom(api_request["response"][0], response_path)
-    test_value = json.loads(Template(value).render(**fixtures))
+    response_value = glom(context["api_request"]["response"][0], response_path)
+    test_value = json.loads(Template(value).render(**context))
     assert test_value == response_value
 
 
 @then(parsers.parse('the response "{response_path}" has the same value as "{fixture_path}"'))
-def expect_equal_value(api_request, fixtures, response_path, fixture_path):
-    fixture_value = glom(fixtures, fixture_path)
-    response_value = glom(api_request["response"][0], response_path)
+def expect_equal_value(context, response_path, fixture_path):
+    fixture_value = glom(context, fixture_path)
+    response_value = glom(context["api_request"]["response"][0], response_path)
     assert fixture_value == response_value
 
 
@@ -414,6 +449,6 @@ def expect_equal_value(api_request, fixtures, response_path, fixture_length):
 
 
 @then(parsers.parse('the response "{response_path}" is false'))
-def expect_false(api_request, response_path):
-    response_value = glom(api_request["response"][0], response_path)
+def expect_false(context, response_path):
+    response_value = glom(context["api_request"]["response"][0], response_path)
     assert not response_value

tests/v1/cassettes/test_list_ip_ranges_returns_ok_response.frozen

@@ -0,0 +1 @@
+2020-09-24T15:22:49.668210+02:00

tests/v1/cassettes/test_list_ip_ranges_returns_ok_response.yaml

@@ -9,13 +9,13 @@ interactions:
       Dd-Operation-Id:
       - GetIpRanges
       User-Agent:
-      - datadog-api-client-python/0.1.dev67+dirty (python 3.8.5; os Darwin; arch x86_64)
+      - datadog-api-client-python/0.1.dev66+dirty (python 3.8.2; os Darwin; arch x86_64)
       x-datadog-parent-id:
-      - '3810264299572682533'
+      - '10148525951698483321'
       x-datadog-sampling-priority:
       - '1'
       x-datadog-trace-id:
-      - '18298303860074712282'
+      - '10171452926111618949'
     method: GET
     uri: https://ip-ranges.datadoghq.com/
   response:
@@ -316,16 +316,14 @@ interactions:
     headers:
       Accept-Ranges:
       - bytes
-      Age:
-      - '32'
       Connection:
       - keep-alive
       Content-Length:
       - '27449'
       Content-Type:
       - application/json
       Date:
-      - Fri, 18 Sep 2020 11:51:12 GMT
+      - Thu, 24 Sep 2020 13:22:51 GMT
       ETag:
       - '"a10a4e3f85ed8c2509855388e149972a"'
       Last-Modified:
@@ -335,13 +333,13 @@ interactions:
       Vary:
       - Accept-Encoding
       Via:
-      - 1.1 960b47175d6cfc9ed048624de2747035.cloudfront.net (CloudFront)
+      - 1.1 bfb83f89a06636844c21e465f3ea5acf.cloudfront.net (CloudFront)
       X-Amz-Cf-Id:
-      - 5ags5K5jwp3hZhwNEgfIo8HYE8a8H1kJQCFA2CCWxvwO9dV6q4JyzQ==
+      - T8zhfoQyuT0N75mlu4Kmot22acMZbddJm1TLEyMHcHZkborBncUEWQ==
       X-Amz-Cf-Pop:
-      - MAD51-C2
+      - CDG3-C2
       X-Cache:
-      - Hit from cloudfront
+      - RefreshHit from cloudfront
     status:
       code: 200
       message: OK

tests/v2/cassettes/test_add_a_user_to_a_role_returns_ok_response.frozen

@@ -1 +1 @@
-2020-09-18T13:52:21.913614+02:00
+2020-09-24T12:01:15.787127+02:00