Adding web app tests (#13)

* Adding web app tests

Signed-off-by: Denis Makogon <[email protected]>

* addressing review comments

Signed-off-by: Denis Makogon <[email protected]>

Author: denismakogon

cloudevents/sdk/converters/base.py

@@ -21,8 +21,13 @@ class Converter(object):
 
     TYPE = None
 
-    def read(self, event, headers: dict, body: typing.IO,
-             data_unmarshaller: typing.Callable) -> base.BaseEvent:
+    def read(
+        self,
+        event,
+        headers: dict,
+        body: typing.IO,
+        data_unmarshaller: typing.Callable
+    ) -> base.BaseEvent:
         raise Exception("not implemented")
 
     def event_supported(self, event: object) -> bool:
@@ -31,6 +36,9 @@ def event_supported(self, event: object) -> bool:
     def can_read(self, content_type: str) -> bool:
         raise Exception("not implemented")
 
-    def write(self, event: base.BaseEvent,
-              data_marshaller: typing.Callable) -> (dict, typing.IO):
+    def write(
+        self,
+        event: base.BaseEvent,
+        data_marshaller: typing.Callable
+    ) -> (dict, object):
         raise Exception("not implemented")

cloudevents/sdk/converters/binary.py

@@ -23,25 +23,29 @@
 class BinaryHTTPCloudEventConverter(base.Converter):
 
     TYPE = "binary"
-    SUPPORTED_VERSIONS = [v02.Event, ]
+    SUPPORTED_VERSIONS = [v02.Event]
 
     def can_read(self, content_type: str) -> bool:
         return True
 
     def event_supported(self, event: object) -> bool:
         return type(event) in self.SUPPORTED_VERSIONS
 
-    def read(self,
-             event: event_base.BaseEvent,
-             headers: dict, body: typing.IO,
-             data_unmarshaller: typing.Callable) -> event_base.BaseEvent:
+    def read(
+        self,
+        event: event_base.BaseEvent,
+        headers: dict,
+        body: typing.IO,
+        data_unmarshaller: typing.Callable,
+    ) -> event_base.BaseEvent:
         if type(event) not in self.SUPPORTED_VERSIONS:
             raise exceptions.UnsupportedEvent(type(event))
         event.UnmarshalBinary(headers, body, data_unmarshaller)
         return event
 
-    def write(self, event: event_base.BaseEvent,
-              data_marshaller: typing.Callable) -> (dict, typing.IO):
+    def write(
+        self, event: event_base.BaseEvent, data_marshaller: typing.Callable
+    ) -> (dict, typing.IO):
         return event.MarshalBinary(data_marshaller)
 
 

cloudevents/sdk/converters/structured.py

@@ -30,17 +30,20 @@ def event_supported(self, event: object) -> bool:
         # structured format supported by both spec 0.1 and 0.2
         return True
 
-    def read(self, event: event_base.BaseEvent,
-             headers: dict,
-             body: typing.IO,
-             data_unmarshaller: typing.Callable) -> event_base.BaseEvent:
+    def read(
+        self,
+        event: event_base.BaseEvent,
+        headers: dict,
+        body: typing.IO,
+        data_unmarshaller: typing.Callable,
+    ) -> event_base.BaseEvent:
         event.UnmarshalJSON(body, data_unmarshaller)
         return event
 
-    def write(self,
-              event: event_base.BaseEvent,
-              data_marshaller: typing.Callable) -> (dict, typing.IO):
-        http_headers = {'content-type': self.MIME_TYPE}
+    def write(
+        self, event: event_base.BaseEvent, data_marshaller: typing.Callable
+    ) -> (dict, typing.IO):
+        http_headers = {"content-type": self.MIME_TYPE}
         return http_headers, event.MarshalJSON(data_marshaller)
 
 

cloudevents/sdk/event/base.py

@@ -18,7 +18,6 @@
 
 
 class EventGetterSetter(object):
-
     def CloudEventVersion(self) -> str:
         raise Exception("not implemented")
 
@@ -76,18 +75,13 @@ def SetContentType(self, contentType: str) -> object:
 
 
 class BaseEvent(EventGetterSetter):
-
     def Properties(self, with_nullable=False) -> dict:
         props = dict()
         for name, value in self.__dict__.items():
             if str(name).startswith("ce__"):
                 v = value.get()
                 if v is not None or with_nullable:
-                    props.update(
-                        {
-                            str(name).replace("ce__", ""): value.get()
-                        }
-                    )
+                    props.update({str(name).replace("ce__", ""): value.get()})
 
         return props
 
@@ -119,33 +113,38 @@ def MarshalJSON(self, data_marshaller: typing.Callable) -> typing.IO:
         props["data"] = data_marshaller(props.get("data"))
         return io.BytesIO(json.dumps(props).encode("utf-8"))
 
-    def UnmarshalJSON(self, b: typing.IO,
-                      data_unmarshaller: typing.Callable):
+    def UnmarshalJSON(self, b: typing.IO, data_unmarshaller: typing.Callable):
         raw_ce = json.load(b)
         for name, value in raw_ce.items():
             if name == "data":
                 value = data_unmarshaller(value)
             self.Set(name, value)
 
-    def UnmarshalBinary(self, headers: dict, body: typing.IO,
-                        data_unmarshaller: typing.Callable):
-        BINARY_MAPPING = {
-            'content-type': 'contenttype',
+    def UnmarshalBinary(
+        self,
+        headers: dict,
+        body: typing.IO,
+        data_unmarshaller: typing.Callable
+    ):
+        binary_mapping = {
+            "content-type": "contenttype",
             # TODO(someone): add Distributed Tracing. It's not clear
             # if this is one extension or two.
             # https://github.com/cloudevents/spec/blob/master/extensions/distributed-tracing.md
         }
         for header, value in headers.items():
             header = header.lower()
-            if header in BINARY_MAPPING:
-                self.Set(BINARY_MAPPING[header], value)
+            if header in binary_mapping:
+                self.Set(binary_mapping[header], value)
             elif header.startswith("ce-"):
                 self.Set(header[3:], value)
 
         self.Set("data", data_unmarshaller(body))
 
     def MarshalBinary(
-            self, data_marshaller: typing.Callable) -> (dict, object):
+            self,
+            data_marshaller: typing.Callable
+    ) -> (dict, object):
         headers = {}
         if self.ContentType():
             headers["content-type"] = self.ContentType()
@@ -159,5 +158,4 @@ def MarshalBinary(
             headers["ce-{0}".format(key)] = value
 
         data, _ = self.Get("data")
-        return headers, io.BytesIO(
-            str(data_marshaller(data)).encode("utf-8"))
+        return headers, data_marshaller(data)

cloudevents/sdk/event/opt.py

@@ -14,7 +14,6 @@
 
 
 class Option(object):
-
     def __init__(self, name, value, is_required):
         self.name = name
         self.value = value
@@ -25,7 +24,9 @@ def set(self, new_value):
         if self.is_required and is_none:
             raise ValueError(
                 "Attribute value error: '{0}', "
-                "invalid new value.".format(self.name))
+                "" "invalid new value."
+                .format(self.name)
+            )
 
         self.value = new_value
 

cloudevents/sdk/event/v01.py

@@ -12,25 +12,62 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from cloudevents.sdk.event import opt
 from cloudevents.sdk.event import base
+from cloudevents.sdk.event import opt
 
 
 class Event(base.BaseEvent):
-
     def __init__(self):
         self.ce__cloudEventsVersion = opt.Option(
-            "cloudEventsVersion", "0.1", True)
-        self.ce__eventType = opt.Option("eventType", None, True)
+            "cloudEventsVersion",
+            "0.1",
+            True
+        )
+        self.ce__eventType = opt.Option(
+            "eventType",
+            None,
+            True
+        )
         self.ce__eventTypeVersion = opt.Option(
-            "eventTypeVersion", None, False)
-        self.ce__source = opt.Option("source", None, True)
-        self.ce__eventID = opt.Option("eventID", None, True)
-        self.ce__eventTime = opt.Option("eventTime", None, True)
-        self.ce__schemaURL = opt.Option("schemaURL", None, False)
-        self.ce__contentType = opt.Option("contentType", None, False)
-        self.ce__data = opt.Option("data", None, False)
-        self.ce__extensions = opt.Option("extensions", dict(), False)
+            "eventTypeVersion",
+            None,
+            False
+        )
+        self.ce__source = opt.Option(
+            "source",
+            None,
+            True
+        )
+        self.ce__eventID = opt.Option(
+            "eventID",
+            None,
+            True
+        )
+        self.ce__eventTime = opt.Option(
+            "eventTime",
+            None,
+            True
+        )
+        self.ce__schemaURL = opt.Option(
+            "schemaURL",
+            None,
+            False
+        )
+        self.ce__contentType = opt.Option(
+            "contentType",
+            None,
+            False
+        )
+        self.ce__data = opt.Option(
+            "data",
+            None,
+            False
+        )
+        self.ce__extensions = opt.Option(
+            "extensions",
+            dict(),
+            False
+        )
 
     def CloudEventVersion(self) -> str:
         return self.ce__cloudEventsVersion.get()

cloudevents/sdk/event/v02.py

@@ -12,12 +12,11 @@
 #    License for the specific language governing permissions and limitations
 #    under the License.
 
-from cloudevents.sdk.event import opt
 from cloudevents.sdk.event import base
+from cloudevents.sdk.event import opt
 
 
 class Event(base.BaseEvent):
-
     def __init__(self):
         self.ce__specversion = opt.Option("specversion", "0.2", True)
         self.ce__type = opt.Option("type", None, True)

cloudevents/sdk/exceptions.py

@@ -14,34 +14,34 @@
 
 
 class UnsupportedEvent(Exception):
-
     def __init__(self, event_class):
-        super().__init__("Invalid CloudEvent class: "
-                         "'{0}'".format(event_class))
+        super().__init__(
+            "Invalid CloudEvent class: '{0}'".format(event_class)
+        )
 
 
 class InvalidDataUnmarshaller(Exception):
-
     def __init__(self):
-        super().__init__(
-            "Invalid data unmarshaller, is not a callable")
+        super().__init__("Invalid data unmarshaller, is not a callable")
 
 
 class InvalidDataMarshaller(Exception):
-
     def __init__(self):
         super().__init__(
-            "Invalid data marshaller, is not a callable")
+            "Invalid data marshaller, is not a callable"
+        )
 
 
 class NoSuchConverter(Exception):
     def __init__(self, converter_type):
         super().__init__(
-            "No such converter {0}".format(converter_type))
+            "No such converter {0}".format(converter_type)
+        )
 
 
 class UnsupportedEventConverter(Exception):
     def __init__(self, content_type):
         super().__init__(
             "Unable to identify valid event converter "
-            "for content-type: '{0}'".format(content_type))
+            "for content-type: '{0}'".format(content_type)
+        )