Add individual tests for each supported Put* operation (#29)

Added individual resources and tests for each of the `Put*` operations. I chose to test them all separately so that errors in one do not impact any of the others.

Author: RedbackThomson

test/e2e/resources/bucket_accelerate.yaml

@@ -0,0 +1,8 @@
+apiVersion: s3.services.k8s.aws/v1alpha1
+kind: Bucket
+metadata:
+  name: $BUCKET_NAME
+spec:
+  name: $BUCKET_NAME
+  accelerate:
+    status: Enabled

test/e2e/resources/bucket_cors.yaml

@@ -0,0 +1,13 @@
+apiVersion: s3.services.k8s.aws/v1alpha1
+kind: Bucket
+metadata:
+  name: $BUCKET_NAME
+spec:
+  name: $BUCKET_NAME
+  cors:
+    corsRules:
+    - allowedMethods:
+      - GET
+      - PUT
+      allowedOrigins:
+      - localhost

test/e2e/resources/bucket_encryption.yaml

@@ -0,0 +1,11 @@
+apiVersion: s3.services.k8s.aws/v1alpha1
+kind: Bucket
+metadata:
+  name: $BUCKET_NAME
+spec:
+  name: $BUCKET_NAME
+  encryption:
+    rules:
+    - bucketKeyEnabled: false
+      applyServerSideEncryptionByDefault:
+        sseAlgorithm: AES256

test/e2e/resources/bucket_logging.yaml

@@ -0,0 +1,11 @@
+apiVersion: s3.services.k8s.aws/v1alpha1
+kind: Bucket
+metadata:
+  name: $BUCKET_NAME
+spec:
+  name: $BUCKET_NAME
+  acl: log-delivery-write
+  logging:
+    loggingEnabled:
+      targetBucket: $BUCKET_NAME
+      targetPrefix: "logging-"

test/e2e/resources/bucket_ownership_controls.yaml

@@ -0,0 +1,9 @@
+apiVersion: s3.services.k8s.aws/v1alpha1
+kind: Bucket
+metadata:
+  name: $BUCKET_NAME
+spec:
+  name: $BUCKET_NAME
+  ownershipControls:
+    rules:
+    - objectOwnership: ObjectWriter

test/e2e/resources/bucket_request_payment.yaml

@@ -0,0 +1,8 @@
+apiVersion: s3.services.k8s.aws/v1alpha1
+kind: Bucket
+metadata:
+  name: $BUCKET_NAME
+spec:
+  name: $BUCKET_NAME
+  requestPayment:
+    payer: Requester

test/e2e/resources/bucket_tagging.yaml

@@ -0,0 +1,12 @@
+apiVersion: s3.services.k8s.aws/v1alpha1
+kind: Bucket
+metadata:
+  name: $BUCKET_NAME
+spec:
+  name: $BUCKET_NAME
+  tagging:
+    tagSet:
+    - key: "first"
+      value: "1"
+    - key: "second"
+      value: "2"

test/e2e/resources/bucket_website.yaml

@@ -0,0 +1,11 @@
+apiVersion: s3.services.k8s.aws/v1alpha1
+kind: Bucket
+metadata:
+  name: $BUCKET_NAME
+spec:
+  name: $BUCKET_NAME
+  website:
+    indexDocument:
+      suffix: index.html
+    errorDocument:
+      key: error.html

test/e2e/tests/test_bucket.py

@@ -18,7 +18,6 @@
 import pytest
 import time
 import logging
-from typing import Dict, Tuple
 
 from acktest.resources import random_suffix_name
 from acktest.k8s import resource as k8s
@@ -31,66 +30,183 @@
 CREATE_WAIT_AFTER_SECONDS = 10
 DELETE_WAIT_AFTER_SECONDS = 10
 
+def get_bucket(s3_resource, bucket_name: str):
+    return s3_resource.Bucket(bucket_name)
+
+def bucket_exists(s3_client, bucket_name: str) -> bool:
+    try:
+        resp = s3_client.list_buckets()
+    except Exception as e:
+        logging.debug(e)
+        return False
+
+    buckets = resp["Buckets"]
+    for bucket in buckets:
+        if bucket["Name"] == bucket_name:
+            return True
+
+    return False
+
+def create_bucket(s3_client, resource_file_name: str):
+    resource_name = random_suffix_name("s3-bucket", 24)
+
+    replacements = REPLACEMENT_VALUES.copy()
+    replacements["BUCKET_NAME"] = resource_name
+
+    # Load Bucket CR
+    resource_data = load_s3_resource(
+        resource_file_name,
+        additional_replacements=replacements,
+    )
+    logging.debug(resource_data)
+
+    # Create k8s resource
+    ref = k8s.CustomResourceReference(
+        CRD_GROUP, CRD_VERSION, RESOURCE_PLURAL,
+        resource_name, namespace="default",
+    )
+    k8s.create_custom_resource(ref, resource_data)
+    cr = k8s.wait_resource_consumed_by_controller(ref)
+
+    assert cr is not None
+    assert k8s.get_resource_exists(ref)
+
+    time.sleep(CREATE_WAIT_AFTER_SECONDS)
+
+    # Check S3 Bucket exists
+    exists = bucket_exists(s3_client, resource_name)
+    assert exists
+
+    return (ref, resource_name, resource_data)
+
+def delete_bucket(s3_client, ref, resource_name):
+    # Delete k8s resource
+    _, deleted = k8s.delete_custom_resource(ref)
+    assert deleted is True
+
+    time.sleep(DELETE_WAIT_AFTER_SECONDS)
+
+    # Check S3 Bucket doesn't exists
+    exists = bucket_exists(s3_client, resource_name)
+    assert not exists
+
 @pytest.fixture(scope="module")
 def s3_client():
     return boto3.client("s3")
 
+@pytest.fixture(scope="module")
+def s3_resource():
+    return boto3.resource("s3")
+
 @service_marker
 @pytest.mark.canary
 class TestBucket:
-    def get_bucket(self, s3_client, bucket_name: str) -> dict:
-        try:
-            resp = s3_client.list_buckets()
-        except Exception as e:
-            logging.debug(e)
-            return None
-
-        buckets = resp["Buckets"]
-        for bucket in buckets:
-            if bucket["Name"] == bucket_name:
-                return bucket
-
-        return None
-
-    def bucket_exists(self, s3_client, bucket_name: str) -> bool:
-        return self.get_bucket(s3_client, bucket_name) is not None
-
-    def test_smoke(self, s3_client):
-        resource_name = random_suffix_name("s3-bucket", 24)
-
-        replacements = REPLACEMENT_VALUES.copy()
-        replacements["BUCKET_NAME"] = resource_name
-
-        # Load Bucket CR
-        resource_data = load_s3_resource(
-            "bucket",
-            additional_replacements=replacements,
-        )
-        logging.debug(resource_data)
-
-        # Create k8s resource
-        ref = k8s.CustomResourceReference(
-            CRD_GROUP, CRD_VERSION, RESOURCE_PLURAL,
-            resource_name, namespace="default",
-        )
-        k8s.create_custom_resource(ref, resource_data)
-        cr = k8s.wait_resource_consumed_by_controller(ref)
-
-        assert cr is not None
-        assert k8s.get_resource_exists(ref)
-
-        time.sleep(CREATE_WAIT_AFTER_SECONDS)
-
-        # Check S3 Bucket exists
-        exists = self.bucket_exists(s3_client, resource_name)
-        assert exists
-
-        # Delete k8s resource
-        _, deleted = k8s.delete_custom_resource(ref)
-        assert deleted is True
-
-        time.sleep(DELETE_WAIT_AFTER_SECONDS)
-
-        # Check S3 Bucket doesn't exists
-        exists = self.bucket_exists(s3_client, resource_name)
-        assert not exists
+    def test_basic(self, s3_client):
+        (ref, resource_name, _) = create_bucket(s3_client, "bucket")
+        delete_bucket(s3_client, ref, resource_name)
+
+    def test_accelerate(self, s3_client):
+        (ref, resource_name, resource_data) = create_bucket(s3_client, "bucket_accelerate")
+        
+        accelerate_configuration = s3_client.get_bucket_accelerate_configuration(Bucket=resource_name)
+        assert resource_data["spec"]["accelerate"]["status"] == accelerate_configuration["Status"]
+
+        delete_bucket(s3_client, ref, resource_name)
+
+    def test_cors(self, s3_client, s3_resource):
+        (ref, resource_name, resource_data) = create_bucket(s3_client, "bucket_cors")
+        
+        # Do checks
+        bucket = get_bucket(s3_resource, resource_name)
+        cors = bucket.Cors()
+
+        desired_rule = resource_data["spec"]["cors"]["corsRules"][0]
+        latest_rule = cors.cors_rules[0]
+
+        assert desired_rule.get("allowedMethods", []) == latest_rule.get("AllowedMethods", [])
+        assert desired_rule.get("allowedOrigins", []) == latest_rule.get("AllowedOrigins", [])
+        assert desired_rule.get("allowedHeaders", []) == latest_rule.get("AllowedHeaders", [])
+        assert desired_rule.get("exposeHeaders", []) == latest_rule.get("ExposeHeaders", [])
+
+        delete_bucket(s3_client, ref, resource_name)
+
+    def test_encryption(self, s3_client):
+        (ref, resource_name, resource_data) = create_bucket(s3_client, "bucket_encryption")
+
+        encryption = s3_client.get_bucket_encryption(Bucket=resource_name)
+        
+        desired_rule = resource_data["spec"]["encryption"]["rules"][0]
+        latest_rule = encryption["ServerSideEncryptionConfiguration"]["Rules"][0]
+
+        assert desired_rule["applyServerSideEncryptionByDefault"]["sseAlgorithm"] == \
+            latest_rule["ApplyServerSideEncryptionByDefault"]["SSEAlgorithm"]
+
+        delete_bucket(s3_client, ref, resource_name)
+
+    def test_logging(self, s3_client, s3_resource):
+        (ref, resource_name, resource_data) = create_bucket(s3_client, "bucket_logging")
+        
+        bucket = get_bucket(s3_resource, resource_name)
+        logging = bucket.Logging()
+
+        desired = resource_data["spec"]["logging"]["loggingEnabled"]
+        latest = logging.logging_enabled
+
+        assert desired["targetBucket"] == latest["TargetBucket"]
+        assert desired["targetPrefix"] == latest["TargetPrefix"]
+
+        delete_bucket(s3_client, ref, resource_name)
+
+    def test_ownership_controls(self, s3_client):
+        (ref, resource_name, resource_data) = create_bucket(s3_client, "bucket_ownership_controls")
+
+        ownership_controls = s3_client.get_bucket_ownership_controls(Bucket=resource_name)
+        
+        desired_rule = resource_data["spec"]["ownershipControls"]["rules"][0]
+        latest_rule = ownership_controls["OwnershipControls"]["Rules"][0]
+
+        assert desired_rule["objectOwnership"] == latest_rule["ObjectOwnership"]
+
+        delete_bucket(s3_client, ref, resource_name)
+
+    def test_request_payment(self, s3_client, s3_resource):
+        (ref, resource_name, resource_data) = create_bucket(s3_client, "bucket_request_payment")
+
+        bucket = get_bucket(s3_resource, resource_name)
+        request_payment = bucket.RequestPayment()
+
+        desired = resource_data["spec"]["requestPayment"]["payer"]
+        latest = request_payment.payer
+
+        assert desired == latest
+
+        delete_bucket(s3_client, ref, resource_name)
+
+    def test_tagging(self, s3_client, s3_resource):
+        (ref, resource_name, resource_data) = create_bucket(s3_client, "bucket_tagging")
+
+        bucket = get_bucket(s3_resource, resource_name)
+        tagging = bucket.Tagging()
+
+        desired = resource_data["spec"]["tagging"]["tagSet"]
+        latest = tagging.tag_set
+
+        for i in range(2):
+            assert desired[i]["key"] == latest[i]["Key"]
+            assert desired[i]["value"] == latest[i]["Value"]
+
+        delete_bucket(s3_client, ref, resource_name)
+
+    def test_website(self, s3_client, s3_resource):
+        (ref, resource_name, resource_data) = create_bucket(s3_client, "bucket_website")
+
+        bucket = get_bucket(s3_resource, resource_name)
+        website = bucket.Website()
+
+        desired = resource_data["spec"]["website"]
+        latest = website
+
+        assert desired["errorDocument"]["key"] == latest.error_document["Key"]
+        assert desired["indexDocument"]["suffix"] == latest.index_document["Suffix"]
+
+        delete_bucket(s3_client, ref, resource_name)