Repository: featureform/featureform (language: python)

Issue:
Add dashboard repo and change Github CI to test dashboard



Discussion / hints:
LGTM

Fix patch:
diff --git a/provider/connection/connection_configs.json b/provider/connection/connection_configs.json
index c5e4a66896..c58c958960 100644
--- a/provider/connection/connection_configs.json
+++ b/provider/connection/connection_configs.json
@@ -1,18 +1,121 @@
 {
-  "BigQuery": {
-      "ProjectID": "some-project-id",
-      "DatasetID": "some-dataset-id",
-      "Credentials": {
-        "Project": "some-project-id",
-        "SecretKey": "my-secret-key"
+  "RedisConfig": { "Addr": "host:1", "Password": "password", "DB": 1 },
+  "PineconeConfig": {
+    "ProjectID": "1",
+    "Environment": "local",
+    "ApiKey": "api_key"
+  },
+  "WeaviateConfig": { "URL": "url", "ApiKey": "api_key" },
+  "GCSFileStoreConfig": {
+    "BucketName": "bucket_name",
+    "BucketPath": "bucket_path",
+    "Credentials": {
+      "ProjectId": "id",
+      "JSON": { "username": "username", "password:": "password" }
     }
   },
-  "Firestore": {
+  "AzureFileStoreConfig": {
+    "AccountName": "name",
+    "AccountKey": "key",
+    "ContainerName": "name",
+    "Path": "/path"
+  },
+  "S3StoreConfig": {
+    "Credentials": { "AWSAccessKeyId": "id", "AWSSecretKey": "key" },
+    "BucketRegion": "bucket_region",
+    "BucketPath": "bucket_path",
+    "Path": ""
+  },
+  "HDFSConfig": {
+    "Host": "host",
+    "Port": "port",
+    "Path": "/path",
+    "Username": "username"
+  },
+  "OnlineBlobConfig": {
+    "Type": "LOCAL_FILESYSTEM",
+    "Config": {
+      "AccountName": "name",
+      "AccountKey": "key",
+      "ContainerName": "name",
+      "Path": "/path"
+    }
+  },
+  "FirestoreConfig": {
     "ProjectID": "some-project-id",
     "Collection": "some-collection-id",
     "Credentials": {
       "Project": "some-project-id",
       "SecretKey": "my-secret-key"
     }
-  }
-}
\ No newline at end of file
+  },
+  "CassandraConfig": {
+    "Keyspace": "keyspace",
+    "Addr": "host:port",
+    "Username": "username",
+    "Password": "password",
+    "Consistency": "consistency",
+    "Replication": 1
+  },
+  "DynamodbConfig": {
+    "Region": "region",
+    "AccessKey": "access_key",
+    "SecretKey": "secret_key"
+  },
+  "MongoDBConfig": {
+    "Username": "username",
+    "Password": "password",
+    "Host": "host",
+    "Port": "port",
+    "Database": "database",
+    "Throughput": 1
+  },
+  "SnowflakeConfig": {
+    "Username": "username",
+    "Password": "password",
+    "Organization": "organization",
+    "AccountLocator": "",
+    "Account": "account",
+    "Schema": "schema",
+    "Database": "",
+    "Warehouse": "warehouse",
+    "Role": "role"
+  },
+  "PostgresConfig": {
+    "Host": "host",
+    "Port": "port",
+    "Username": "username",
+    "Password": "password",
+    "Database": "database"
+  },
+  "RedshiftConfig": {
+    "Host": "host",
+    "Port": "port",
+    "Username": "username",
+    "Password": "password",
+    "Database": "database"
+  },
+  "BigQueryConfig": {
+    "ProjectID": "some-project-id",
+    "DatasetID": "some-dataset-id",
+    "Credentials": {
+      "Project": "some-project-id",
+      "SecretKey": "my-secret-key"
+    }
+  },
+  "SparkConfig": {
+    "ExecutorType": "executor_type",
+    "StoreType": "LOCAL_FILESYSTEM",
+    "ExecutorConfig": {},
+    "StoreConfig": {}
+  },
+  "K8sConfig": {
+    "ExecutorType": "K8S",
+    "ExecutorConfig": { "docker_image": "docker_image" },
+    "StoreType": "store_type",
+    "StoreConfig": {}
+  },
+  "EmptyConfig": {},
+  "LocalConfig": {},
+  "MemoryConfig": {}
+}
diff --git a/provider/connection/mock_credentials.json b/provider/connection/mock_credentials.json
new file mode 100644
index 0000000000..0347fb21b9
--- /dev/null
+++ b/provider/connection/mock_credentials.json
@@ -0,0 +1,4 @@
+{
+  "username": "username",
+  "password:": "password"
+}


Test patch:
diff --git a/client/tests/provider_config_test.py b/client/tests/provider_config_test.py
index 44bda467c8..ab7e044aca 100644
--- a/client/tests/provider_config_test.py
+++ b/client/tests/provider_config_test.py
@@ -1,42 +1,280 @@
 import json
 import sys
+
 import pytest
-import os
 
 sys.path.insert(0, "client/src/")
-from featureform.resources import BigQueryConfig, FirestoreConfig
+from featureform.resources import (
+    BigQueryConfig,
+    FirestoreConfig,
+    RedisConfig,
+    PineconeConfig,
+    WeaviateConfig,
+    GCSFileStoreConfig,
+    GCPCredentials,
+    AzureFileStoreConfig,
+    S3StoreConfig,
+    AWSCredentials,
+    HDFSConfig,
+    OnlineBlobConfig,
+    CassandraConfig,
+    DynamodbConfig,
+    MongoDBConfig,
+    SnowflakeConfig,
+    PostgresConfig,
+    SparkConfig,
+    K8sConfig,
+    RedshiftConfig,
+)
+import featureform.resources as resources
+import inspect
 
+connection_configs = json.load(open("provider/connection/connection_configs.json"))
+mock_credentials = json.load(open("provider/connection/mock_credentials.json"))
 
-@pytest.fixture
-def connection_configs():
-    return json.load(open("provider/connection/connection_configs.json"))
 
+@pytest.mark.local
+def test_config_list():
+    """assert that each config is present, if this test fails
+    you likely added a config, but forgot to add a test and associated config schema in connection_configs.json.
+    The file is used in provider_config_test.(go|py), offline_test.go, and online_test.go.
+    """
+    config_list = [
+        x
+        for x in dir(resources)
+        if inspect.isclass(getattr(resources, x)) and x.endswith("Config")
+    ]
+    for config_class in config_list:
+        assert config_class in connection_configs
 
-@pytest.fixture
-def bigquery_config(connection_configs):
-    return connection_configs["BigQuery"]
 
+@pytest.mark.local
+def test_redis():
+    expected_config = connection_configs["RedisConfig"]
+    conf = RedisConfig(
+        host="host",
+        port=1,
+        password="password",
+        db=1,
+    )
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
 
-def test_bigquery(bigquery_config):
-    conf = BigQueryConfig(
-        project_id=bigquery_config["ProjectID"],
-        dataset_id=bigquery_config["DatasetID"],
-        credentials_path="provider/connection/gcp_test_credentials.json",
+
+@pytest.mark.local
+def test_pinecone():
+    expected_config = connection_configs["PineconeConfig"]
+    conf = PineconeConfig(project_id="1", environment="local", api_key="api_key")
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
+
+
+@pytest.mark.local
+def test_weaviate():
+    expected_config = connection_configs["WeaviateConfig"]
+    conf = WeaviateConfig(url="url", api_key="api_key")
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
+
+
+@pytest.mark.local
+def test_gcsfilestore():
+    expected_config = connection_configs["GCSFileStoreConfig"]
+    conf = GCSFileStoreConfig(
+        credentials=GCPCredentials(
+            project_id="id",
+            credentials_path="provider/connection/mock_credentials.json",
+        ),
+        bucket_name="bucket_name",
+        bucket_path="bucket_path",
     )
     serialized_config = conf.serialize()
-    assert json.loads(serialized_config) == bigquery_config
+    assert json.loads(serialized_config) == expected_config
+
 
+@pytest.mark.local
+def test_azurefilestore():
+    expected_config = connection_configs["AzureFileStoreConfig"]
+    conf = AzureFileStoreConfig(
+        account_name="name", account_key="key", container_name="name", root_path="/path"
+    )
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
 
-@pytest.fixture
-def firestore_config(connection_configs):
-    return connection_configs["Firestore"]
 
+@pytest.mark.local
+def test_s3store():
+    expected_config = connection_configs["S3StoreConfig"]
+    conf = S3StoreConfig(
+        bucket_path="bucket_path",
+        bucket_region="bucket_region",
+        credentials=AWSCredentials(aws_access_key_id="id", aws_secret_access_key="key"),
+    )
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
 
-def test_firestore(firestore_config):
+
+@pytest.mark.local
+def test_hdfs():
+    expected_config = connection_configs["HDFSConfig"]
+    conf = HDFSConfig(host="host", port="port", path="/path", username="username")
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
+
+
+@pytest.mark.local
+def test_hdfs():
+    expected_config = connection_configs["HDFSConfig"]
+    conf = HDFSConfig(host="host", port="port", path="/path", username="username")
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
+
+
+@pytest.mark.local
+def test_onlineblob():
+    expected_config = connection_configs["OnlineBlobConfig"]
+    config = {
+        "AccountName": "name",
+        "AccountKey": "key",
+        "ContainerName": "name",
+        "Path": "/path",
+    }
+    conf = OnlineBlobConfig(store_type="LOCAL_FILESYSTEM", store_config=config)
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
+
+
+@pytest.mark.local
+def test_firestore():
+    expected_config = connection_configs["FirestoreConfig"]
     conf = FirestoreConfig(
-        project_id=firestore_config["ProjectID"],
-        collection=firestore_config["Collection"],
+        project_id="some-project-id",
+        collection="some-collection-id",
         credentials_path="provider/connection/gcp_test_credentials.json",
     )
     serialized_config = conf.serialize()
-    assert json.loads(serialized_config) == firestore_config
+    assert json.loads(serialized_config) == expected_config
+
+
+@pytest.mark.local
+def test_cassandra():
+    expected_config = connection_configs["CassandraConfig"]
+    conf = CassandraConfig(
+        keyspace="keyspace",
+        host="host",
+        port="port",
+        username="username",
+        password="password",
+        consistency="consistency",
+        replication=1,
+    )
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
+
+
+@pytest.mark.local
+def test_dynamodb():
+    expected_config = connection_configs["DynamodbConfig"]
+    conf = DynamodbConfig(
+        region="region",
+        access_key="access_key",
+        secret_key="secret_key",
+    )
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
+
+
+@pytest.mark.local
+def test_mongodb():
+    expected_config = connection_configs["MongoDBConfig"]
+    conf = MongoDBConfig(
+        username="username",
+        password="password",
+        host="host",
+        port="port",
+        database="database",
+        throughput=1,
+    )
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
+
+
+@pytest.mark.local
+def test_snowflake():
+    expected_config = connection_configs["SnowflakeConfig"]
+    conf = SnowflakeConfig(
+        username="username",
+        password="password",
+        schema="schema",
+        account="account",
+        organization="organization",
+        warehouse="warehouse",
+        role="role",
+    )
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
+
+
+@pytest.mark.local
+def test_postgres():
+    expected_config = connection_configs["PostgresConfig"]
+    conf = PostgresConfig(
+        host="host",
+        port="port",
+        database="database",
+        user="username",
+        password="password",
+    )
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
+
+
+@pytest.mark.local
+def test_redshift():
+    expected_config = connection_configs["RedshiftConfig"]
+    conf = RedshiftConfig(
+        host="host",
+        port="port",
+        database="database",
+        user="username",
+        password="password",
+    )
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
+
+
+@pytest.mark.local
+def test_bigquery():
+    expected_config = connection_configs["BigQueryConfig"]
+    conf = BigQueryConfig(
+        project_id=expected_config["ProjectID"],
+        dataset_id=expected_config["DatasetID"],
+        credentials_path="provider/connection/gcp_test_credentials.json",
+    )
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
+
+
+@pytest.mark.local
+def test_spark():
+    expected_config = connection_configs["SparkConfig"]
+    conf = SparkConfig(
+        executor_type="executor_type",
+        executor_config=dict(),
+        store_type="LOCAL_FILESYSTEM",
+        store_config=dict(),
+    )
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
+
+
+@pytest.mark.local
+def test_k8sconfig():
+    expected_config = connection_configs["K8sConfig"]
+    conf = K8sConfig(
+        store_type="store_type",
+        store_config=dict(),
+        docker_image="docker_image",
+    )
+    serialized_config = conf.serialize()
+    assert json.loads(serialized_config) == expected_config
diff --git a/provider/offline_test.go b/provider/offline_test.go
index a78ee0f506..ab71caf568 100644
--- a/provider/offline_test.go
+++ b/provider/offline_test.go
@@ -3526,7 +3526,7 @@ func TestBigQueryConfig_Deserialize(t *testing.T) {
 	if err != nil {
 		t.Fatalf(err.Error())
 	}
-	testConfig := payload["BigQuery"].(map[string]interface{})
+	testConfig := payload["BigQueryConfig"].(map[string]interface{})
 
 	bgconfig := pc.BigQueryConfig{
 		ProjectId:   testConfig["ProjectID"].(string),
diff --git a/provider/online_test.go b/provider/online_test.go
index a1fce3e0a9..50327ebcbd 100644
--- a/provider/online_test.go
+++ b/provider/online_test.go
@@ -418,7 +418,7 @@ func TestFirestoreConfig_Deserialize(t *testing.T) {
 	if err != nil {
 		t.Fatalf(err.Error())
 	}
-	testConfig := payload["Firestore"].(map[string]interface{})
+	testConfig := payload["FirestoreConfig"].(map[string]interface{})
 
 	fsconfig := pc.FirestoreConfig{
 		ProjectID:   testConfig["ProjectID"].(string),
diff --git a/provider/provider_config/provider_config_test.go b/provider/provider_config/provider_config_test.go
new file mode 100644
index 0000000000..165734aaa9
--- /dev/null
+++ b/provider/provider_config/provider_config_test.go
@@ -0,0 +1,521 @@
+package provider_config
+
+import (
+	"encoding/json"
+	"fmt"
+	"os"
+	"testing"
+
+	pt "github.com/featureform/provider/provider_type"
+	"github.com/stretchr/testify/assert"
+)
+
+var providerMap = map[string]string{
+	"LOCAL_ONLINE":      "LocalConfig",
+	"REDIS_ONLINE":      "RedisConfig",
+	"CASSANDRA_ONLINE":  "CassandraConfig",
+	"FIRESTORE_ONLINE":  "FirestoreConfig",
+	"DYNAMODB_ONLINE":   "DynamodbConfig",
+	"BLOB_ONLINE":       "OnlineBlobConfig",
+	"MONGODB_ONLINE":    "MongoDbConfig",
+	"PINECONE_ONLINE":   "PineconeConfig",
+	"POSTGRES_OFFLINE":  "PostgresConfig",
+	"SNOWFLAKE_OFFLINE": "SnowflakeConfig",
+	"REDSHIFT_OFFLINE":  "RedshiftConfig",
+	"SPARK_OFFLINE":     "SparkConfig",
+	"BIGQUERY_OFFLINE":  "BigQueryConfig",
+	"K8S_OFFLINE":       "K8sConfig",
+	"S3":                "S3StoreConfig",
+	"GCS":               "GCSFileStoreConfig",
+	"HDFS":              "HDFSConfig",
+	"AZURE":             "AzureFileStoreConfig",
+	"MEMORY_OFFLINE":    "MemoryConfig",
+}
+
+/*
+assert that each config is present, if this test fails
+you likely added a config, but forgot to add a test and associated config schema in connection_configs.json.
+The file is used in provider_config_test.(go|py), offline_test.go, and online_test.go.
+*/
+func TestAllProviderTypesHasMapEntry(t *testing.T) {
+	proList := pt.AllProviderTypes
+
+	for _, currentProvider := range proList {
+		foundEntry := providerMap[string(currentProvider)]
+		errorMsg := fmt.Sprintf("This provider type (%s) is not present in the providerMap.", currentProvider)
+		assert.NotEmpty(t, foundEntry, errorMsg)
+	}
+}
+
+func getConnectionConfigs() ([]byte, error) {
+	connectionConfigs, err := os.ReadFile("../connection/connection_configs.json")
+	if err != nil {
+		return nil, err
+	}
+	return connectionConfigs, nil
+}
+
+func TestRedis(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["RedisConfig"].(map[string]interface{})
+	instance := RedisConfig{
+		Addr:     config["Addr"].(string),
+		Password: config["Password"].(string),
+		DB:       int(config["DB"].(float64)),
+	}
+
+	assert.NotNil(t, instance)
+}
+
+func TestCassandra(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["CassandraConfig"].(map[string]interface{})
+	instance := CassandraConfig{
+		Keyspace:    config["Keyspace"].(string),
+		Addr:        config["Addr"].(string),
+		Username:    config["Username"].(string),
+		Password:    config["Password"].(string),
+		Consistency: config["Consistency"].(string),
+		Replication: int(config["Replication"].(float64)),
+	}
+
+	assert.NotNil(t, instance)
+}
+
+func TestFirestore(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["FirestoreConfig"].(map[string]interface{})
+	credentials := config["Credentials"].(map[string]interface{})
+	instance := FirestoreConfig{
+		Collection:  config["Collection"].(string),
+		ProjectID:   config["ProjectID"].(string),
+		Credentials: credentials,
+	}
+
+	assert.NotNil(t, instance)
+}
+
+func TestDynamo(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["DynamodbConfig"].(map[string]interface{})
+	instance := DynamodbConfig{
+		Region:    config["Region"].(string),
+		AccessKey: config["AccessKey"].(string),
+		SecretKey: config["SecretKey"].(string),
+	}
+
+	assert.NotNil(t, instance)
+}
+
+func TestBlob(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["OnlineBlobConfig"].(map[string]interface{})
+	blobType := config["Type"].(string)
+	credentials := config["Config"].(map[string]interface{})
+	azureConfig := AzureFileStoreConfig{
+		AccountName:   credentials["AccountName"].(string),
+		AccountKey:    credentials["AccountKey"].(string),
+		ContainerName: credentials["ContainerName"].(string),
+		Path:          credentials["Path"].(string),
+	}
+	instance := OnlineBlobConfig{
+		Type:   FileStoreType(blobType),
+		Config: azureConfig,
+	}
+
+	assert.NotNil(t, instance)
+}
+
+func TestMongo(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["MongoDBConfig"].(map[string]interface{})
+	instance := MongoDBConfig{
+		Username:   config["Username"].(string),
+		Password:   config["Password"].(string),
+		Host:       config["Host"].(string),
+		Port:       config["Port"].(string),
+		Database:   config["Database"].(string),
+		Throughput: int(config["Throughput"].(float64)),
+	}
+
+	assert.NotNil(t, instance)
+}
+
+func TestPinecone(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["PineconeConfig"].(map[string]interface{})
+	instance := PineconeConfig{
+		ProjectID:   config["ProjectID"].(string),
+		Environment: config["Environment"].(string),
+		ApiKey:      config["ApiKey"].(string),
+	}
+
+	assert.NotNil(t, instance)
+}
+
+func TestPostgres(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["PostgresConfig"].(map[string]interface{})
+	instance := PostgresConfig{
+		Host:     config["Host"].(string),
+		Port:     config["Port"].(string),
+		Username: config["Username"].(string),
+		Password: config["Password"].(string),
+		Database: config["Database"].(string),
+	}
+
+	assert.NotNil(t, instance)
+}
+
+func TestSnowflake(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["SnowflakeConfig"].(map[string]interface{})
+	instance := SnowflakeConfig{
+		Username:       config["Username"].(string),
+		Password:       config["Password"].(string),
+		Organization:   config["Organization"].(string),
+		AccountLocator: config["AccountLocator"].(string),
+		Account:        config["Account"].(string),
+		Schema:         config["Schema"].(string),
+		Database:       config["Database"].(string),
+		Warehouse:      config["Warehouse"].(string),
+		Role:           config["Role"].(string),
+	}
+
+	assert.NotNil(t, instance)
+}
+
+func TestRedshift(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["RedshiftConfig"].(map[string]interface{})
+	instance := RedshiftConfig{
+		Endpoint: config["Host"].(string),
+		Port:     config["Port"].(string),
+		Username: config["Username"].(string),
+		Password: config["Password"].(string),
+		Database: config["Database"].(string),
+	}
+
+	assert.NotNil(t, instance)
+}
+
+type SparkDummy struct {
+}
+
+func (SparkDummy) Serialize() ([]byte, error) {
+	return []byte{}, nil
+}
+
+func (SparkDummy) Deserialize(config SerializedConfig) error {
+	return nil
+}
+
+func (SparkDummy) IsExecutorConfig() bool {
+	return true
+}
+
+func (SparkDummy) IsFileStoreConfig() bool {
+	return true
+}
+
+func TestSpark(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["SparkConfig"].(map[string]interface{})
+	execType := config["ExecutorType"].(string)
+	instance := SparkConfig{
+		ExecutorType:   SparkExecutorType(execType),
+		ExecutorConfig: SparkDummy{},
+		StoreType:      FileStoreType(config["StoreType"].(string)),
+		StoreConfig:    SparkDummy{},
+	}
+
+	assert.NotNil(t, instance)
+}
+
+func TestBigQuery(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["BigQueryConfig"].(map[string]interface{})
+	instance := BigQueryConfig{
+		ProjectId:   config["ProjectID"].(string),
+		DatasetId:   config["DatasetID"].(string),
+		Credentials: config["Credentials"].(map[string]interface{}),
+	}
+
+	assert.NotNil(t, instance)
+}
+
+type K8sDummy struct {
+}
+
+func (K8sDummy) Serialize() ([]byte, error) {
+	return []byte{}, nil
+}
+
+func (K8sDummy) Deserialize(config SerializedConfig) error {
+	return nil
+}
+
+func (K8sDummy) IsFileStoreConfig() bool {
+	return true
+}
+
+func TestK8S(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["K8sConfig"].(map[string]interface{})
+	instance := K8sConfig{
+		ExecutorType:   ExecutorType(config["ExecutorType"].(string)),
+		ExecutorConfig: K8sDummy{},
+		StoreType:      FileStoreType(config["StoreType"].(string)),
+		StoreConfig:    K8sDummy{},
+	}
+
+	assert.NotNil(t, instance)
+}
+
+func TestS3(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["S3StoreConfig"].(map[string]interface{})
+	credendials := config["Credentials"].(map[string]interface{})
+	awsCreds := AWSCredentials{
+		AWSAccessKeyId: credendials["AWSAccessKeyId"].(string),
+		AWSSecretKey:   credendials["AWSSecretKey"].(string),
+	}
+	instance := S3FileStoreConfig{
+		Credentials:  awsCreds,
+		BucketRegion: config["BucketRegion"].(string),
+		BucketPath:   config["BucketPath"].(string),
+		Path:         config["Path"].(string),
+	}
+
+	assert.NotNil(t, instance)
+}
+
+func TestGCS(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["GCSFileStoreConfig"].(map[string]interface{})
+	credentials := config["Credentials"].(map[string]interface{})
+	gcpCredentials := GCPCredentials{
+		ProjectId: credentials["ProjectId"].(string),
+		JSON:      credentials["JSON"].(map[string]interface{}),
+	}
+	instance := GCSFileStoreConfig{
+		Credentials: gcpCredentials,
+		BucketName:  config["BucketName"].(string),
+		BucketPath:  config["BucketPath"].(string),
+	}
+
+	assert.NotNil(t, instance)
+}
+
+func TestHDFSConfig(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["HDFSConfig"].(map[string]interface{})
+	instance := HDFSFileStoreConfig{
+		Host:     config["Host"].(string),
+		Port:     config["Port"].(string),
+		Path:     config["Path"].(string),
+		Username: config["Username"].(string),
+	}
+
+	assert.NotNil(t, instance)
+}
+
+func TestAzure(t *testing.T) {
+	connectionConfigs, err := getConnectionConfigs()
+	if err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	var jsonDict map[string]interface{}
+	if err = json.Unmarshal(connectionConfigs, &jsonDict); err != nil {
+		println(err)
+		t.FailNow()
+	}
+
+	config := jsonDict["AzureFileStoreConfig"].(map[string]interface{})
+	instance := AzureFileStoreConfig{
+		AccountName:   config["AccountName"].(string),
+		AccountKey:    config["AccountKey"].(string),
+		ContainerName: config["ContainerName"].(string),
+		Path:          config["Path"].(string),
+	}
+
+	assert.NotNil(t, instance)
+}