github.com/gagliardetto/solana-go@v1.11.0/rpc/ws/client_test.go (about)

     1  // Copyright 2021 github.com/gagliardetto
     2  // This file has been modified by github.com/gagliardetto
     3  //
     4  // Copyright 2020 dfuse Platform Inc.
     5  //
     6  // Licensed under the Apache License, Version 2.0 (the "License");
     7  // you may not use this file except in compliance with the License.
     8  // You may obtain a copy of the License at
     9  //
    10  //      http://www.apache.org/licenses/LICENSE-2.0
    11  //
    12  // Unless required by applicable law or agreed to in writing, software
    13  // distributed under the License is distributed on an "AS IS" BASIS,
    14  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    15  // See the License for the specific language governing permissions and
    16  // limitations under the License.
    17  
    18  package ws
    19  
    20  import (
    21  	"context"
    22  	"encoding/base64"
    23  	"fmt"
    24  	"net/http"
    25  	"os"
    26  	"testing"
    27  	"time"
    28  
    29  	"github.com/gagliardetto/solana-go"
    30  	"github.com/gagliardetto/solana-go/text"
    31  	"github.com/stretchr/testify/require"
    32  	"go.uber.org/zap"
    33  )
    34  
    35  func Test_AccountSubscribe(t *testing.T) {
    36  	t.Skip("Never ending test, revisit me to not depend on actual network calls, or hide between env flag")
    37  
    38  	zlog, _ = zap.NewDevelopment()
    39  
    40  	c, err := Connect(context.Background(), "ws://api.mainnet-beta.solana.com:80")
    41  	defer c.Close()
    42  	require.NoError(t, err)
    43  
    44  	accountID := solana.MustPublicKeyFromBase58("SqJP6vrvMad5XBQK5PCFEZjeuQSFi959sdpqtSNvnsX")
    45  	sub, err := c.AccountSubscribe(accountID, "")
    46  	require.NoError(t, err)
    47  
    48  	data, err := sub.Recv()
    49  	if err != nil {
    50  		fmt.Println("receive an error: ", err)
    51  		return
    52  	}
    53  	text.NewEncoder(os.Stdout).Encode(data, nil)
    54  	fmt.Println("OpenOrders: ", data.Value.Account.Owner)
    55  	fmt.Println("data: ", data.Value.Account.Data)
    56  	return
    57  }
    58  
    59  func Test_AccountSubscribeWithHttpHeader(t *testing.T) {
    60  	t.Skip("Never ending test, revisit me to not depend on actual network calls, or hide between env flag")
    61  	zlog, _ = zap.NewDevelopment()
    62  
    63  	// Pass in bogus websocket authentication credentials
    64  	wssUser := "john"
    65  	wssPass := "do not use me"
    66  	opt := &Options{
    67  		HttpHeader: http.Header{
    68  			"Authorization": []string{
    69  				"Basic " + base64.StdEncoding.EncodeToString([]byte(wssUser+":"+wssPass)),
    70  			},
    71  		},
    72  	}
    73  
    74  	c, err := ConnectWithOptions(context.TODO(), "ws://api.mainnet-beta.solana.com:80", opt)
    75  	defer c.Close()
    76  	require.NoError(t, err)
    77  
    78  	accountID := solana.MustPublicKeyFromBase58("SqJP6vrvMad5XBQK5PCFEZjeuQSFi959sdpqtSNvnsX")
    79  	sub, err := c.AccountSubscribe(accountID, "")
    80  	require.NoError(t, err)
    81  
    82  	// seconds waiting before disconnecting from socket
    83  	const timeoutSeconds = 3
    84  	go func(sub *AccountSubscription) {
    85  		ticker := time.NewTicker(1 * time.Second)
    86  		secs := 0
    87  		for range ticker.C {
    88  			secs++
    89  			t.Logf("%d...", secs)
    90  			if secs == timeoutSeconds {
    91  				ticker.Stop()
    92  				break
    93  			}
    94  		}
    95  		sub.Unsubscribe()
    96  	}(sub)
    97  
    98  	data, err := sub.Recv()
    99  	if err != nil {
   100  		t.Errorf("Received an error: %v", err)
   101  	}
   102  	if data == nil {
   103  		return
   104  	}
   105  
   106  	if err := text.NewEncoder(os.Stdout).Encode(data, nil); err != nil {
   107  		t.Errorf("encoding error: %v", err)
   108  	}
   109  
   110  	t.Log("OpenOrders: ", data.Value.Account.Owner)
   111  	t.Log("data: ", data.Value.Account.Data)
   112  }
   113  
   114  func Test_ProgramSubscribe(t *testing.T) {
   115  	t.Skip("Never ending test, revisit me to not depend on actual network calls, or hide between env flag")
   116  
   117  	zlog, _ = zap.NewDevelopment()
   118  
   119  	fmt.Println("Dialing")
   120  	c, err := Connect(context.Background(), "wss://solana-api.projectserum.com")
   121  	fmt.Println("Hello?")
   122  	defer c.Close()
   123  	require.NoError(t, err)
   124  
   125  	programID := solana.MustPublicKeyFromBase58("EUqojwWA2rd19FZrzeBncJsm38Jm1hEhE3zsmX3bRc2o")
   126  	sub, err := c.ProgramSubscribe(programID, "")
   127  	require.NoError(t, err)
   128  
   129  	for {
   130  		data, err := sub.Recv()
   131  		if err != nil {
   132  			fmt.Println("receive an error: ", err)
   133  			return
   134  		}
   135  		fmt.Println("data received: ", data.Value.Pubkey)
   136  	}
   137  
   138  }
   139  func Test_SlotSubscribe(t *testing.T) {
   140  	t.Skip("Never ending test, revisit me to not depend on actual network calls, or hide between env flag")
   141  
   142  	zlog, _ = zap.NewDevelopment()
   143  
   144  	c, err := Connect(context.Background(), "ws://api.mainnet-beta.solana.com:80")
   145  	defer c.Close()
   146  	require.NoError(t, err)
   147  
   148  	sub, err := c.SlotSubscribe()
   149  	require.NoError(t, err)
   150  
   151  	data, err := sub.Recv()
   152  	if err != nil {
   153  		fmt.Println("receive an error: ", err)
   154  		return
   155  	}
   156  	fmt.Println("data received: ", data.Parent)
   157  	return
   158  }