main_test.go

Documentation: edge-infra.dev/pkg/edge/psqlinjector/integration

     1  package server_test
     2  
     3  import (
     4  	"context"
     5  	"database/sql"
     6  	"fmt"
     7  	"os"
     8  	"testing"
     9  	"time"
    10  
    11  	server "edge-infra.dev/pkg/edge/psqlinjector"
    12  	"edge-infra.dev/test/f2"
    13  	"edge-infra.dev/test/f2/x/postgres"
    14  	"edge-infra.dev/test/f2/x/pstest"
    15  
    16  	"cloud.google.com/go/pubsub"
    17  	"github.com/google/uuid"
    18  	"github.com/stretchr/testify/require"
    19  	"google.golang.org/api/option"
    20  )
    21  
    22  var f2f f2.Framework
    23  
    24  func TestMain(m *testing.M) {
    25  	var pg = postgres.New(postgres.ApplySeedModel()) // don't set postgres.SkipSchemaIsolation()
    26  	var pub = pstest.New(pstest.WithProjectID("test_id"))
    27  
    28  	f2f = f2.New(context.Background(), f2.WithExtensions(pg, pub))
    29  
    30  	os.Exit(f2f.Run(m))
    31  }
    32  
    33  func setupConfig(ctx f2.Context, t *testing.T, cfg *server.Config) f2.Context {
    34  	cfg.DelayScrapeMessageProcessing = 10 * time.Millisecond
    35  	cfg.HealthzAddr = "127.0.0.1:0"
    36  	cfg.MetricsAddr = "127.0.0.1:0"
    37  	cfg.ForemanProjectID = "ret-edge-foo0-foreman"
    38  	cfg.TopicID = "kinform-psqlinjector"
    39  	cfg.SubscriptionID = "psqlinjector"
    40  	cfg.TestPubSubConn = pstest.FromContextT(ctx, t).Conn
    41  	cfg.PollBannersMaxRetries = 1
    42  	cfg.PollBannersPeriod = 27 * time.Millisecond
    43  	cfg.PollSubscriptionExistsPeriod = 11 * time.Millisecond
    44  	cfg.DB = postgres.FromContextT(ctx, t).DB()
    45  	return ctx
    46  }
    47  
    48  func createPubSubClient(ctx f2.Context, t *testing.T, projectID string) *pubsub.Client {
    49  	ps := pstest.FromContextT(ctx, t)
    50  	client, err := pubsub.NewClient(ctx, projectID, option.WithGRPCConn(ps.Conn))
    51  	require.NoError(t, err, "error creating pubsub client")
    52  	return client
    53  }
    54  
    55  func createKinformTopics(ctx f2.Context, t *testing.T, cfg *server.Config, projectIDs ...string) f2.Context {
    56  	for _, p := range projectIDs {
    57  		var client = createPubSubClient(ctx, t, p)
    58  
    59  		topic, err := client.CreateTopic(ctx, cfg.TopicID)
    60  		require.NoError(t, err, "error creating pubsub topic")
    61  
    62  		exists, err := topic.Exists(ctx)
    63  		require.NoError(t, err, "error checking if topic exists")
    64  		require.True(t, exists, "topic does not exist")
    65  
    66  		sub, err := client.CreateSubscription(ctx, cfg.SubscriptionID, pubsub.SubscriptionConfig{Topic: topic})
    67  		require.NoError(t, err, "error creating subscription")
    68  
    69  		exists, err = sub.Exists(ctx)
    70  		require.NoError(t, err, "error checking if subscription exists")
    71  		require.True(t, exists, "subscription does not exist")
    72  	}
    73  	return ctx
    74  }
    75  
    76  // populateTablesWithProjectIDs inserts each project ID into the database
    77  func populateTablesWithProjectIDs(ctx f2.Context, t *testing.T, projectIDs ...string) (clusterEdgeIDs map[string]uuid.UUID) {
    78  	// minimum statments needed to create these entries.
    79  	const stmtInsertTenant = "INSERT INTO tenants (tenant_edge_id, org_id, org_name) VALUES ($1, $2, $3)"
    80  	const stmtInsertBanner = "INSERT INTO banners(project_id, banner_edge_id, banner_bsl_id, banner_name, tenant_edge_id) VALUES($1, $2, $3, $4, $5)"
    81  	const stmtInsertCluster = "INSERT INTO clusters(cluster_edge_id, project_id, banner_edge_id, cluster_name) VALUES($1, $2, $3, $4)"
    82  
    83  	var db = postgres.FromContextT(ctx, t).DB()
    84  
    85  	var tenantEdgeID = uuid.New().String()
    86  	var tenantOrgID = uuid.New().String()
    87  	var tenantOrgName = fmt.Sprintf("tenant-%s", tenantOrgID)
    88  	_, err := db.ExecContext(ctx, stmtInsertTenant, tenantEdgeID, tenantOrgID, tenantOrgName)
    89  	require.NoError(t, err, "could not create tenant in database")
    90  
    91  	var bannerIDs = make(map[string]string)
    92  	for _, p := range projectIDs {
    93  		var name = fmt.Sprintf("banner-%s", p)
    94  		var bslID = fmt.Sprintf("bsl-id-%s", p)
    95  
    96  		var id = uuid.New().String()
    97  		bannerIDs[p] = id
    98  
    99  		_, err = db.ExecContext(ctx, stmtInsertBanner, p, id, bslID, name, tenantEdgeID)
   100  		require.NoError(t, err, "could not create banner in database")
   101  	}
   102  
   103  	clusterEdgeIDs = make(map[string]uuid.UUID)
   104  	for i, p := range projectIDs {
   105  		var name = fmt.Sprintf("cluster-%d", i)
   106  
   107  		var id = uuid.New()
   108  		clusterEdgeIDs[p] = id
   109  
   110  		_, err := db.ExecContext(ctx, stmtInsertCluster, id.String(), p, bannerIDs[p], name)
   111  		require.NoError(t, err, "could not create cluster in database")
   112  	}
   113  
   114  	// sanity check
   115  	require.Equalf(t, len(clusterEdgeIDs), len(projectIDs), "there were duplicate projectIDs provided to this function: %v", projectIDs)
   116  
   117  	return clusterEdgeIDs
   118  }
   119  
   120  func selectInfraStatusUpdatedAt(ctx f2.Context, t *testing.T, clusterEdgeIDs map[string]uuid.UUID) map[string]time.Time {
   121  	var stmt = "SELECT infra_status_updated_at FROM clusters WHERE cluster_edge_id=$1"
   122  	var db = postgres.FromContextT(ctx, t).DB()
   123  	var m = make(map[string]time.Time)
   124  	for p, ceid := range clusterEdgeIDs {
   125  		var updated sql.NullTime // infra_status_updated_at can be null
   126  		var row = db.QueryRowContext(ctx, stmt, ceid.String())
   127  		require.NoErrorf(t, row.Scan(&updated), "unable to query cluster infra_status_updated_at for projectID %q", p)
   128  
   129  		m[p] = updated.Time // treat null as zero.
   130  	}
   131  	return m
   132  }
   133
View as plain text