github.com/meowstercatel/discordgo@v0.0.0-20250615204139-29b43d676735/discord_test.go (about)

     1  package discordgo
     2  
     3  import (
     4  	"fmt"
     5  	"os"
     6  	"runtime"
     7  	"sync/atomic"
     8  	"testing"
     9  	"time"
    10  )
    11  
    12  //////////////////////////////////////////////////////////////////////////////
    13  ////////////////////////////////////////////////////// VARS NEEDED FOR TESTING
    14  var (
    15  	dg    *Session // Stores a global discordgo user session
    16  	dgBot *Session // Stores a global discordgo bot session
    17  
    18  	envOAuth2Token  = os.Getenv("DG_OAUTH2_TOKEN")  // Token to use when authenticating using OAuth2 token
    19  	envBotToken     = os.Getenv("DGB_TOKEN")        // Token to use when authenticating the bot account
    20  	envGuild        = os.Getenv("DG_GUILD")         // Guild ID to use for tests
    21  	envChannel      = os.Getenv("DG_CHANNEL")       // Channel ID to use for tests
    22  	envVoiceChannel = os.Getenv("DG_VOICE_CHANNEL") // Channel ID to use for tests
    23  	envAdmin        = os.Getenv("DG_ADMIN")         // User ID of admin user to use for tests
    24  )
    25  
    26  func TestMain(m *testing.M) {
    27  	fmt.Println("Init is being called.")
    28  	if envBotToken != "" {
    29  		if d, err := New(envBotToken); err == nil {
    30  			dgBot = d
    31  		}
    32  	}
    33  
    34  	if envOAuth2Token == "" {
    35  		envOAuth2Token = os.Getenv("DGU_TOKEN")
    36  	}
    37  
    38  	if envOAuth2Token != "" {
    39  		if d, err := New(envOAuth2Token); err == nil {
    40  			dg = d
    41  		}
    42  	}
    43  
    44  	os.Exit(m.Run())
    45  }
    46  
    47  //////////////////////////////////////////////////////////////////////////////
    48  /////////////////////////////////////////////////////////////// START OF TESTS
    49  
    50  // TestNewToken tests the New() function with a Token.
    51  func TestNewToken(t *testing.T) {
    52  
    53  	if envOAuth2Token == "" {
    54  		t.Skip("Skipping New(token), DGU_TOKEN not set")
    55  	}
    56  
    57  	d, err := New(envOAuth2Token)
    58  	if err != nil {
    59  		t.Fatalf("New(envToken) returned error: %+v", err)
    60  	}
    61  
    62  	if d == nil {
    63  		t.Fatal("New(envToken), d is nil, should be Session{}")
    64  	}
    65  
    66  	if d.Token == "" {
    67  		t.Fatal("New(envToken), d.Token is empty, should be a valid Token.")
    68  	}
    69  }
    70  
    71  func TestOpenClose(t *testing.T) {
    72  	if envOAuth2Token == "" {
    73  		t.Skip("Skipping TestClose, DGU_TOKEN not set")
    74  	}
    75  
    76  	d, err := New(envOAuth2Token)
    77  	if err != nil {
    78  		t.Fatalf("TestClose, New(envToken) returned error: %+v", err)
    79  	}
    80  
    81  	if err = d.Open(); err != nil {
    82  		t.Fatalf("TestClose, d.Open failed: %+v", err)
    83  	}
    84  
    85  	// We need a better way to know the session is ready for use,
    86  	// this is totally gross.
    87  	start := time.Now()
    88  	for {
    89  		d.RLock()
    90  		if d.DataReady {
    91  			d.RUnlock()
    92  			break
    93  		}
    94  		d.RUnlock()
    95  
    96  		if time.Since(start) > 10*time.Second {
    97  			t.Fatal("DataReady never became true.yy")
    98  		}
    99  		runtime.Gosched()
   100  	}
   101  
   102  	// TODO find a better way
   103  	// Add a small sleep here to make sure heartbeat and other events
   104  	// have enough time to get fired.  Need a way to actually check
   105  	// those events.
   106  	time.Sleep(2 * time.Second)
   107  
   108  	// UpdateStatus - maybe we move this into wsapi_test.go but the websocket
   109  	// created here is needed.  This helps tests that the websocket was setup
   110  	// and it is working.
   111  	if err = d.UpdateGameStatus(0, time.Now().String()); err != nil {
   112  		t.Errorf("UpdateStatus error: %+v", err)
   113  	}
   114  
   115  	if err = d.Close(); err != nil {
   116  		t.Fatalf("TestClose, d.Close failed: %+v", err)
   117  	}
   118  }
   119  
   120  func TestAddHandler(t *testing.T) {
   121  
   122  	testHandlerCalled := int32(0)
   123  	testHandler := func(s *Session, m *MessageCreate) {
   124  		atomic.AddInt32(&testHandlerCalled, 1)
   125  	}
   126  
   127  	interfaceHandlerCalled := int32(0)
   128  	interfaceHandler := func(s *Session, i interface{}) {
   129  		atomic.AddInt32(&interfaceHandlerCalled, 1)
   130  	}
   131  
   132  	bogusHandlerCalled := int32(0)
   133  	bogusHandler := func(s *Session, se *Session) {
   134  		atomic.AddInt32(&bogusHandlerCalled, 1)
   135  	}
   136  
   137  	d := Session{}
   138  	d.AddHandler(testHandler)
   139  	d.AddHandler(testHandler)
   140  
   141  	d.AddHandler(interfaceHandler)
   142  	d.AddHandler(bogusHandler)
   143  
   144  	d.handleEvent(messageCreateEventType, &MessageCreate{})
   145  	d.handleEvent(messageDeleteEventType, &MessageDelete{})
   146  
   147  	<-time.After(500 * time.Millisecond)
   148  
   149  	// testHandler will be called twice because it was added twice.
   150  	if atomic.LoadInt32(&testHandlerCalled) != 2 {
   151  		t.Fatalf("testHandler was not called twice.")
   152  	}
   153  
   154  	// interfaceHandler will be called twice, once for each event.
   155  	if atomic.LoadInt32(&interfaceHandlerCalled) != 2 {
   156  		t.Fatalf("interfaceHandler was not called twice.")
   157  	}
   158  
   159  	if atomic.LoadInt32(&bogusHandlerCalled) != 0 {
   160  		t.Fatalf("bogusHandler was called.")
   161  	}
   162  }
   163  
   164  func TestRemoveHandler(t *testing.T) {
   165  
   166  	testHandlerCalled := int32(0)
   167  	testHandler := func(s *Session, m *MessageCreate) {
   168  		atomic.AddInt32(&testHandlerCalled, 1)
   169  	}
   170  
   171  	d := Session{}
   172  	r := d.AddHandler(testHandler)
   173  
   174  	d.handleEvent(messageCreateEventType, &MessageCreate{})
   175  
   176  	r()
   177  
   178  	d.handleEvent(messageCreateEventType, &MessageCreate{})
   179  
   180  	<-time.After(500 * time.Millisecond)
   181  
   182  	// testHandler will be called once, as it was removed in between calls.
   183  	if atomic.LoadInt32(&testHandlerCalled) != 1 {
   184  		t.Fatalf("testHandler was not called once.")
   185  	}
   186  }
   187  
   188  func TestScheduledEvents(t *testing.T) {
   189  	if dgBot == nil {
   190  		t.Skip("Skipping, dgBot not set.")
   191  	}
   192  
   193  	beginAt := time.Now().Add(1 * time.Hour)
   194  	endAt := time.Now().Add(2 * time.Hour)
   195  	event, err := dgBot.GuildScheduledEventCreate(envGuild, &GuildScheduledEventParams{
   196  		Name:               "Test Event",
   197  		PrivacyLevel:       GuildScheduledEventPrivacyLevelGuildOnly,
   198  		ScheduledStartTime: &beginAt,
   199  		ScheduledEndTime:   &endAt,
   200  		Description:        "Awesome Test Event created on livestream",
   201  		EntityType:         GuildScheduledEventEntityTypeExternal,
   202  		EntityMetadata: &GuildScheduledEventEntityMetadata{
   203  			Location: "https://discord.com",
   204  		},
   205  	})
   206  	defer dgBot.GuildScheduledEventDelete(envGuild, event.ID)
   207  
   208  	if err != nil || event.Name != "Test Event" {
   209  		t.Fatal(err)
   210  	}
   211  
   212  	events, err := dgBot.GuildScheduledEvents(envGuild, true)
   213  	if err != nil {
   214  		t.Fatal(err)
   215  	}
   216  
   217  	var foundEvent *GuildScheduledEvent
   218  	for _, e := range events {
   219  		if e.ID == event.ID {
   220  			foundEvent = e
   221  			break
   222  		}
   223  	}
   224  	if foundEvent.Name != event.Name {
   225  		t.Fatal("err on GuildScheduledEvents endpoint. Missing Scheduled Event")
   226  	}
   227  
   228  	getEvent, err := dgBot.GuildScheduledEvent(envGuild, event.ID, true)
   229  	if err != nil {
   230  		t.Fatal(err)
   231  	}
   232  	if getEvent.Name != event.Name {
   233  		t.Fatal("err on GuildScheduledEvent endpoint. Mismatched Scheduled Event")
   234  	}
   235  
   236  	eventUpdated, err := dgBot.GuildScheduledEventEdit(envGuild, event.ID, &GuildScheduledEventParams{Name: "Test Event Updated"})
   237  	if err != nil {
   238  		t.Fatal(err)
   239  	}
   240  
   241  	if eventUpdated.Name != "Test Event Updated" {
   242  		t.Fatal("err on GuildScheduledEventUpdate endpoint. Scheduled Event Name mismatch")
   243  	}
   244  
   245  	// Usage of 1 and 1 is just the pseudo data with the purpose to run all branches in the function without crashes.
   246  	// see https://github.com/bwmarrin/discordgo/pull/1032#discussion_r815438303 for more details.
   247  	users, err := dgBot.GuildScheduledEventUsers(envGuild, event.ID, 1, true, "1", "1")
   248  	if err != nil {
   249  		t.Fatal(err)
   250  	}
   251  	if len(users) != 0 {
   252  		t.Fatal("err on GuildScheduledEventUsers. Mismatch of event maybe occurred")
   253  	}
   254  
   255  	err = dgBot.GuildScheduledEventDelete(envGuild, event.ID)
   256  	if err != nil {
   257  		t.Fatal(err)
   258  	}
   259  }
   260  
   261  func TestComplexScheduledEvents(t *testing.T) {
   262  	if dgBot == nil {
   263  		t.Skip("Skipping, dgBot not set.")
   264  	}
   265  
   266  	beginAt := time.Now().Add(1 * time.Hour)
   267  	endAt := time.Now().Add(2 * time.Hour)
   268  	event, err := dgBot.GuildScheduledEventCreate(envGuild, &GuildScheduledEventParams{
   269  		Name:               "Test Voice Event",
   270  		PrivacyLevel:       GuildScheduledEventPrivacyLevelGuildOnly,
   271  		ScheduledStartTime: &beginAt,
   272  		ScheduledEndTime:   &endAt,
   273  		Description:        "Test event on voice channel",
   274  		EntityType:         GuildScheduledEventEntityTypeVoice,
   275  		ChannelID:          envVoiceChannel,
   276  	})
   277  	if err != nil || event.Name != "Test Voice Event" {
   278  		t.Fatal(err)
   279  	}
   280  	defer dgBot.GuildScheduledEventDelete(envGuild, event.ID)
   281  
   282  	_, err = dgBot.GuildScheduledEventEdit(envGuild, event.ID, &GuildScheduledEventParams{
   283  		EntityType: GuildScheduledEventEntityTypeExternal,
   284  		EntityMetadata: &GuildScheduledEventEntityMetadata{
   285  			Location: "https://discord.com",
   286  		},
   287  	})
   288  
   289  	if err != nil {
   290  		t.Fatal("err on GuildScheduledEventEdit. Change of entity type to external failed")
   291  	}
   292  
   293  	_, err = dgBot.GuildScheduledEventEdit(envGuild, event.ID, &GuildScheduledEventParams{
   294  		ChannelID:      envVoiceChannel,
   295  		EntityType:     GuildScheduledEventEntityTypeVoice,
   296  		EntityMetadata: nil,
   297  	})
   298  
   299  	if err != nil {
   300  		t.Fatal("err on GuildScheduledEventEdit. Change of entity type to voice failed")
   301  	}
   302  }