mcias/client/example_test.go

package client_test

import (
	"context"
	"fmt"
	"time"

	"git.wntrmute.dev/kyle/mcias/client"
)

func Example() {
	c := client.NewClient()

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	tokenResp, err := c.LoginWithPassword(ctx, "username", "password")
	if err != nil {
		fmt.Println("Failed to login:", err)
		return
	}

	fmt.Printf("Authenticated with token: %s\n", tokenResp.Token)
	fmt.Printf("Token expires at: %s\n", time.Unix(tokenResp.Expires, 0).Format(time.RFC3339))

	if tokenResp.TOTPEnabled {
		fmt.Println("TOTP is enabled, please enter your TOTP code")
		totpCode := "123456" // In a real application, this would be user input

		totpResp, err := c.VerifyTOTP(ctx, "username", totpCode)
		if err != nil {
			fmt.Println("Failed to verify TOTP:", err)
			return
		}

		fmt.Printf("TOTP verified, new token: %s\n", totpResp.Token)
		fmt.Printf("Token expires at: %s\n", time.Unix(totpResp.Expires, 0).Format(time.RFC3339))
	}

	dbCreds, err := c.GetDatabaseCredentials(ctx, "")
	if err != nil {
		fmt.Println("Failed to get database credentials:", err)
		return
	}

	fmt.Printf("Database Host: %s\n", dbCreds.Host)
	fmt.Printf("Database Port: %d\n", dbCreds.Port)
	fmt.Printf("Database Name: %s\n", dbCreds.Name)
	fmt.Printf("Database User: %s\n", dbCreds.User)
	fmt.Printf("Database Password: %s\n", dbCreds.Password)

	tokenClient := client.NewClient()
	tokenResp, err = tokenClient.LoginWithToken(ctx, "username", "existing-token")
	if err != nil {
		fmt.Println("Failed to login with token:", err)
		return
	}

	fmt.Printf("Authenticated with token: %s\n", tokenResp.Token)
	fmt.Printf("Token expires at: %s\n", time.Unix(tokenResp.Expires, 0).Format(time.RFC3339))

	// Output:
	// Authenticated with token: token
	// Token expires at: 2023-01-01T00:00:00Z
	// Database Host: db.example.com
	// Database Port: 5432
	// Database Name: mydb
	// Database User: dbuser
	// Database Password: dbpass
	// Authenticated with token: token
	// Token expires at: 2023-01-01T00:00:00Z
}

func ExampleClient_LoginWithPassword() {
	c := client.NewClient(
		client.WithBaseURL("https://mcias.example.com"),
	)

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	tokenResp, err := c.LoginWithPassword(ctx, "username", "password")
	if err != nil {
		fmt.Println("Failed to login:", err)
		return
	}

	fmt.Printf("Authenticated with token: %s\n", tokenResp.Token)
	fmt.Printf("Token expires at: %s\n", time.Unix(tokenResp.Expires, 0).Format(time.RFC3339))

	if tokenResp.TOTPEnabled {
		fmt.Println("TOTP verification required")
	}

	// Output:
	// Authenticated with token: token
	// Token expires at: 2023-01-01T00:00:00Z
}

func ExampleClient_LoginWithToken() {
	c := client.NewClient()

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	tokenResp, err := c.LoginWithToken(ctx, "username", "existing-token")
	if err != nil {
		fmt.Println("Failed to login with token:", err)
		return
	}

	fmt.Printf("Authenticated with token: %s\n", tokenResp.Token)
	fmt.Printf("Token expires at: %s\n", time.Unix(tokenResp.Expires, 0).Format(time.RFC3339))

	// Output:
	// Authenticated with token: token
	// Token expires at: 2023-01-01T00:00:00Z
}

func ExampleClient_VerifyTOTP() {
	c := client.NewClient()

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	totpResp, err := c.VerifyTOTP(ctx, "username", "123456")
	if err != nil {
		fmt.Println("Failed to verify TOTP:", err)
		return
	}

	fmt.Printf("TOTP verified, token: %s\n", totpResp.Token)
	fmt.Printf("Token expires at: %s\n", time.Unix(totpResp.Expires, 0).Format(time.RFC3339))

	// Output:
	// TOTP verified, token: token
	// Token expires at: 2023-01-01T00:00:00Z
}

func ExampleClient_GetDatabaseCredentials() {
	c := client.NewClient(
		client.WithUsername("username"),
		client.WithToken("existing-token"),
	)

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	databaseID := "db123"
	dbCreds, err := c.GetDatabaseCredentials(ctx, databaseID)
	if err != nil {
		fmt.Println("Failed to get database credentials:", err)
		return
	}

	fmt.Printf("Database Host: %s\n", dbCreds.Host)
	fmt.Printf("Database Port: %d\n", dbCreds.Port)
	fmt.Printf("Database Name: %s\n", dbCreds.Name)
	fmt.Printf("Database User: %s\n", dbCreds.User)
	fmt.Printf("Database Password: %s\n", dbCreds.Password)

	// Output:
	// Database Host: db.example.com
	// Database Port: 5432
	// Database Name: mydb
	// Database User: dbuser
	// Database Password: dbpass
}

func ExampleClient_GetDatabaseCredentialsList() {
	c := client.NewClient(
		client.WithUsername("username"),
		client.WithToken("existing-token"),
	)

	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()

	dbCredsList, err := c.GetDatabaseCredentialsList(ctx)
	if err != nil {
		fmt.Println("Failed to get database credentials list:", err)
		return
	}

	fmt.Printf("Number of databases: %d\n", len(dbCredsList))

	for i, creds := range dbCredsList {
		fmt.Printf("Database %d:\n", i+1)
		fmt.Printf("  Host: %s\n", creds.Host)
		fmt.Printf("  Port: %d\n", creds.Port)
		fmt.Printf("  Name: %s\n", creds.Name)
		fmt.Printf("  User: %s\n", creds.User)
		fmt.Printf("  Password: %s\n", creds.Password)
	}

	// Output:
	// Number of databases: 2
	// Database 1:
	//   Host: db1.example.com
	//   Port: 5432
	//   Name: mydb1
	//   User: dbuser1
	//   Password: dbpass1
	// Database 2:
	//   Host: db2.example.com
	//   Port: 5432
	//   Name: mydb2
	//   User: dbuser2
	//   Password: dbpass2
}