graph/cosmo_test.go

@@ -33,7 +33,10 @@ func TestGenerateCosmoRouterConfig(t *testing.T) {
 				err := json.Unmarshal([]byte(config), &result)
 				require.NoError(t, err, "Config should be valid JSON")
 
-				assert.Equal(t, "1", result["version"], "Version should be 1")
+				// Version is a UUID string from wgc
+				version, ok := result["version"].(string)
+				require.True(t, ok, "Version should be a string")
+				assert.NotEmpty(t, version, "Version should not be empty")
 
 				subgraphs, ok := result["subgraphs"].([]interface{})
 				require.True(t, ok, "subgraphs should be an array")
@@ -41,14 +44,26 @@ func TestGenerateCosmoRouterConfig(t *testing.T) {
 
 				sg := subgraphs[0].(map[string]interface{})
 				assert.Equal(t, "test-service", sg["name"])
-				assert.Equal(t, "http://localhost:4001/query", sg["routing_url"])
-				assert.Equal(t, "type Query { test: String }", sg["sdl"])
+				assert.Equal(t, "http://localhost:4001/query", sg["routingUrl"])
 
-				subscription, ok := sg["subscription"].(map[string]interface{})
+				// Check that datasource configurations include subscription settings
+				engineConfig, ok := result["engineConfig"].(map[string]interface{})
+				require.True(t, ok, "Should have engineConfig")
+
+				dsConfigs, ok := engineConfig["datasourceConfigurations"].([]interface{})
+				require.True(t, ok && len(dsConfigs) > 0, "Should have datasource configurations")
+
+				ds := dsConfigs[0].(map[string]interface{})
+				customGraphql, ok := ds["customGraphql"].(map[string]interface{})
+				require.True(t, ok, "Should have customGraphql config")
+
+				subscription, ok := customGraphql["subscription"].(map[string]interface{})
 				require.True(t, ok, "Should have subscription config")
-				assert.Equal(t, "ws://localhost:4001/query", subscription["url"])
-				assert.Equal(t, "ws", subscription["protocol"])
-				assert.Equal(t, "graphql-ws", subscription["websocket_subprotocol"])
+				assert.True(t, subscription["enabled"].(bool), "Subscription should be enabled")
+
+				subUrl, ok := subscription["url"].(map[string]interface{})
+				require.True(t, ok, "Should have subscription URL")
+				assert.Equal(t, "ws://localhost:4001/query", subUrl["staticVariableContent"])
 			},
 		},
 		{
@@ -80,18 +95,28 @@ func TestGenerateCosmoRouterConfig(t *testing.T) {
 				subgraphs := result["subgraphs"].([]interface{})
 				assert.Len(t, subgraphs, 3, "Should have 3 subgraphs")
 
-				// Check first service has no subscription
+				// Check service names
 				sg1 := subgraphs[0].(map[string]interface{})
 				assert.Equal(t, "service-1", sg1["name"])
-				_, hasSubscription := sg1["subscription"]
-				assert.False(t, hasSubscription, "service-1 should not have subscription config")
 
-				// Check third service has subscription
 				sg3 := subgraphs[2].(map[string]interface{})
 				assert.Equal(t, "service-3", sg3["name"])
-				subscription, hasSubscription := sg3["subscription"]
-				assert.True(t, hasSubscription, "service-3 should have subscription config")
-				assert.NotNil(t, subscription)
+
+				// Check that datasource configurations include subscription for service-3
+				engineConfig, ok := result["engineConfig"].(map[string]interface{})
+				require.True(t, ok, "Should have engineConfig")
+
+				dsConfigs, ok := engineConfig["datasourceConfigurations"].([]interface{})
+				require.True(t, ok && len(dsConfigs) == 3, "Should have 3 datasource configurations")
+
+				// Find service-3's datasource config (should have subscription enabled)
+				ds3 := dsConfigs[2].(map[string]interface{})
+				customGraphql, ok := ds3["customGraphql"].(map[string]interface{})
+				require.True(t, ok, "Service-3 should have customGraphql config")
+
+				subscription, ok := customGraphql["subscription"].(map[string]interface{})
+				require.True(t, ok, "Service-3 should have subscription config")
+				assert.True(t, subscription["enabled"].(bool), "Service-3 subscription should be enabled")
 			},
 		},
 		{
@@ -113,39 +138,43 @@ func TestGenerateCosmoRouterConfig(t *testing.T) {
 				subgraphs := result["subgraphs"].([]interface{})
 				sg := subgraphs[0].(map[string]interface{})
 
-				// Should not have routing_url or subscription fields if URLs are nil
-				_, hasRoutingURL := sg["routing_url"]
-				assert.False(t, hasRoutingURL, "Should not have routing_url when URL is nil")
+				// Should not have routing URL when URL is nil
+				_, hasRoutingURL := sg["routingUrl"]
+				assert.False(t, hasRoutingURL, "Should not have routingUrl when URL is nil")
 
-				_, hasSubscription := sg["subscription"]
-				assert.False(t, hasSubscription, "Should not have subscription when WsURL is nil")
+				// Check datasource configurations don't have subscription enabled
+				engineConfig, ok := result["engineConfig"].(map[string]interface{})
+				require.True(t, ok, "Should have engineConfig")
+
+				dsConfigs, ok := engineConfig["datasourceConfigurations"].([]interface{})
+				require.True(t, ok && len(dsConfigs) > 0, "Should have datasource configurations")
+
+				ds := dsConfigs[0].(map[string]interface{})
+				customGraphql, ok := ds["customGraphql"].(map[string]interface{})
+				require.True(t, ok, "Should have customGraphql config")
+
+				subscription, ok := customGraphql["subscription"].(map[string]interface{})
+				if ok {
+					// wgc always enables subscription but URL should be empty when WsURL is nil
+					subUrl, hasUrl := subscription["url"].(map[string]interface{})
+					if hasUrl {
+						_, hasStaticContent := subUrl["staticVariableContent"]
+						assert.False(t, hasStaticContent, "Subscription URL should be empty when WsURL is nil")
+					}
+				}
 			},
 		},
 		{
 			name:      "empty subgraphs",
 			subGraphs: []*model.SubGraph{},
-			wantErr:   false,
-			validate: func(t *testing.T, config string) {
-				var result map[string]interface{}
-				err := json.Unmarshal([]byte(config), &result)
-				require.NoError(t, err)
-
-				subgraphs := result["subgraphs"].([]interface{})
-				assert.Len(t, subgraphs, 0, "Should have empty subgraphs array")
-			},
+			wantErr:   true,
+			validate:  nil,
 		},
 		{
 			name:      "nil subgraphs",
 			subGraphs: nil,
-			wantErr:   false,
-			validate: func(t *testing.T, config string) {
-				var result map[string]interface{}
-				err := json.Unmarshal([]byte(config), &result)
-				require.NoError(t, err)
-
-				subgraphs := result["subgraphs"].([]interface{})
-				assert.Len(t, subgraphs, 0, "Should handle nil subgraphs as empty array")
-			},
+			wantErr:   true,
+			validate:  nil,
 		},
 		{
 			name: "complex SDL with multiple types",
@@ -173,13 +202,30 @@ func TestGenerateCosmoRouterConfig(t *testing.T) {
 				err := json.Unmarshal([]byte(config), &result)
 				require.NoError(t, err)
 
-				subgraphs := result["subgraphs"].([]interface{})
-				sg := subgraphs[0].(map[string]interface{})
-				sdl := sg["sdl"].(string)
+				// Check the composed graphqlSchema contains the types
+				engineConfig, ok := result["engineConfig"].(map[string]interface{})
+				require.True(t, ok, "Should have engineConfig")
 
-				assert.Contains(t, sdl, "type Query")
-				assert.Contains(t, sdl, "type User")
-				assert.Contains(t, sdl, "email: String!")
+				graphqlSchema, ok := engineConfig["graphqlSchema"].(string)
+				require.True(t, ok, "Should have graphqlSchema")
+
+				assert.Contains(t, graphqlSchema, "Query", "Schema should contain Query type")
+				assert.Contains(t, graphqlSchema, "User", "Schema should contain User type")
+
+				// Check datasource has the original SDL
+				dsConfigs, ok := engineConfig["datasourceConfigurations"].([]interface{})
+				require.True(t, ok && len(dsConfigs) > 0, "Should have datasource configurations")
+
+				ds := dsConfigs[0].(map[string]interface{})
+				customGraphql, ok := ds["customGraphql"].(map[string]interface{})
+				require.True(t, ok, "Should have customGraphql config")
+
+				federation, ok := customGraphql["federation"].(map[string]interface{})
+				require.True(t, ok, "Should have federation config")
+
+				serviceSdl, ok := federation["serviceSdl"].(string)
+				require.True(t, ok, "Should have serviceSdl")
+				assert.Contains(t, serviceSdl, "email: String!", "SDL should contain email field")
 			},
 		},
 	}