032c426ac3
GUI packages, examples, and documentation for building desktop applications with Go and web technologies. Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>
636 lines
18 KiB
Go
636 lines
18 KiB
Go
package electroncompat
|
|
|
|
import (
|
|
"errors"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/assert"
|
|
)
|
|
|
|
func TestNotImplementedError(t *testing.T) {
|
|
t.Run("creates error with service and method", func(t *testing.T) {
|
|
err := notImplemented("TestService", "testMethod")
|
|
assert.Error(t, err)
|
|
assert.Equal(t, "IPC TestService.testMethod is not implemented", err.Error())
|
|
})
|
|
|
|
t.Run("implements error interface", func(t *testing.T) {
|
|
err := notImplemented("Service", "method")
|
|
var notImplErr *NotImplementedError
|
|
assert.True(t, errors.As(err, ¬ImplErr))
|
|
assert.Equal(t, "Service", notImplErr.Service)
|
|
assert.Equal(t, "method", notImplErr.Method)
|
|
})
|
|
}
|
|
|
|
func TestErrNotImplemented(t *testing.T) {
|
|
assert.Equal(t, "not implemented", ErrNotImplemented.Error())
|
|
}
|
|
|
|
// Helper to check if error is NotImplementedError
|
|
func assertNotImplemented(t *testing.T, err error) {
|
|
t.Helper()
|
|
var notImplErr *NotImplementedError
|
|
assert.True(t, errors.As(err, ¬ImplErr), "expected NotImplementedError")
|
|
}
|
|
|
|
func TestNodeService(t *testing.T) {
|
|
svc := NewNodeService()
|
|
assert.NotNil(t, svc)
|
|
|
|
t.Run("Start", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Start())
|
|
})
|
|
t.Run("Stop", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Stop())
|
|
})
|
|
t.Run("Reset", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Reset())
|
|
})
|
|
t.Run("GenerateToAddress", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.GenerateToAddress("addr", 1))
|
|
})
|
|
t.Run("GetAPIKey", func(t *testing.T) {
|
|
_, err := svc.GetAPIKey()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetNoDns", func(t *testing.T) {
|
|
_, err := svc.GetNoDns()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetSpvMode", func(t *testing.T) {
|
|
_, err := svc.GetSpvMode()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetInfo", func(t *testing.T) {
|
|
_, err := svc.GetInfo()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetNameInfo", func(t *testing.T) {
|
|
_, err := svc.GetNameInfo("name")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetTXByAddresses", func(t *testing.T) {
|
|
_, err := svc.GetTXByAddresses([]string{"addr"})
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetNameByHash", func(t *testing.T) {
|
|
_, err := svc.GetNameByHash("hash")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetBlockByHeight", func(t *testing.T) {
|
|
_, err := svc.GetBlockByHeight(1)
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetTx", func(t *testing.T) {
|
|
_, err := svc.GetTx("hash")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("BroadcastRawTx", func(t *testing.T) {
|
|
_, err := svc.BroadcastRawTx("tx")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SendRawAirdrop", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.SendRawAirdrop("proof"))
|
|
})
|
|
t.Run("GetFees", func(t *testing.T) {
|
|
_, err := svc.GetFees()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetAverageBlockTime", func(t *testing.T) {
|
|
_, err := svc.GetAverageBlockTime()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetMTP", func(t *testing.T) {
|
|
_, err := svc.GetMTP()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetCoin", func(t *testing.T) {
|
|
_, err := svc.GetCoin("hash", 0)
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("VerifyMessageWithName", func(t *testing.T) {
|
|
_, err := svc.VerifyMessageWithName("name", "sig", "msg")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SetNodeDir", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.SetNodeDir("dir"))
|
|
})
|
|
t.Run("SetAPIKey", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.SetAPIKey("key"))
|
|
})
|
|
t.Run("SetNoDns", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.SetNoDns(true))
|
|
})
|
|
t.Run("SetSpvMode", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.SetSpvMode(true))
|
|
})
|
|
t.Run("GetDir", func(t *testing.T) {
|
|
_, err := svc.GetDir()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetHNSPrice", func(t *testing.T) {
|
|
_, err := svc.GetHNSPrice()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("TestCustomRPCClient", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.TestCustomRPCClient("host", 8080, "key"))
|
|
})
|
|
t.Run("GetDNSSECProof", func(t *testing.T) {
|
|
_, err := svc.GetDNSSECProof("name")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SendRawClaim", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.SendRawClaim("claim"))
|
|
})
|
|
}
|
|
|
|
func TestWalletService(t *testing.T) {
|
|
svc := NewWalletService()
|
|
assert.NotNil(t, svc)
|
|
|
|
t.Run("Start", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Start())
|
|
})
|
|
t.Run("GetAPIKey", func(t *testing.T) {
|
|
_, err := svc.GetAPIKey()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SetAPIKey", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.SetAPIKey("key"))
|
|
})
|
|
t.Run("GetWalletInfo", func(t *testing.T) {
|
|
_, err := svc.GetWalletInfo("id")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetAccountInfo", func(t *testing.T) {
|
|
_, err := svc.GetAccountInfo("wallet", "account")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetCoin", func(t *testing.T) {
|
|
_, err := svc.GetCoin("hash", 0)
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetTX", func(t *testing.T) {
|
|
_, err := svc.GetTX("hash")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetNames", func(t *testing.T) {
|
|
_, err := svc.GetNames("wallet")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("CreateNewWallet", func(t *testing.T) {
|
|
_, err := svc.CreateNewWallet("id", "pass")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("ImportSeed", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.ImportSeed("id", "pass", "mnemonic"))
|
|
})
|
|
t.Run("GenerateReceivingAddress", func(t *testing.T) {
|
|
_, err := svc.GenerateReceivingAddress("wallet", "account")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetAuctionInfo", func(t *testing.T) {
|
|
_, err := svc.GetAuctionInfo("name")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetTransactionHistory", func(t *testing.T) {
|
|
_, err := svc.GetTransactionHistory("wallet")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetPendingTransactions", func(t *testing.T) {
|
|
_, err := svc.GetPendingTransactions("wallet")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetBids", func(t *testing.T) {
|
|
_, err := svc.GetBids("wallet", true)
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetBlind", func(t *testing.T) {
|
|
_, err := svc.GetBlind(100, "nonce")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetMasterHDKey", func(t *testing.T) {
|
|
_, err := svc.GetMasterHDKey("wallet", "pass")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("HasAddress", func(t *testing.T) {
|
|
_, err := svc.HasAddress("wallet", "addr")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SetPassphrase", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.SetPassphrase("wallet", "old", "new"))
|
|
})
|
|
t.Run("RevealSeed", func(t *testing.T) {
|
|
_, err := svc.RevealSeed("wallet", "pass")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("EstimateTxFee", func(t *testing.T) {
|
|
_, err := svc.EstimateTxFee(1000)
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("EstimateMaxSend", func(t *testing.T) {
|
|
_, err := svc.EstimateMaxSend("wallet", "account", 1000)
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("RemoveWalletById", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.RemoveWalletById("id"))
|
|
})
|
|
t.Run("UpdateAccountDepth", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.UpdateAccountDepth("wallet", "account", 100))
|
|
})
|
|
t.Run("FindNonce", func(t *testing.T) {
|
|
_, err := svc.FindNonce("name", "addr", 100)
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("FindNonceCancel", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.FindNonceCancel())
|
|
})
|
|
t.Run("EncryptWallet", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.EncryptWallet("wallet", "pass"))
|
|
})
|
|
t.Run("Backup", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Backup("wallet", "path"))
|
|
})
|
|
t.Run("Rescan", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Rescan(0))
|
|
})
|
|
t.Run("DeepClean", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.DeepClean("wallet"))
|
|
})
|
|
t.Run("Reset", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Reset())
|
|
})
|
|
t.Run("SendOpen", func(t *testing.T) {
|
|
_, err := svc.SendOpen("wallet", "pass", "name")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SendBid", func(t *testing.T) {
|
|
_, err := svc.SendBid("wallet", "pass", "name", 100, 200)
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SendRegister", func(t *testing.T) {
|
|
_, err := svc.SendRegister("wallet", "pass", "name")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SendUpdate", func(t *testing.T) {
|
|
_, err := svc.SendUpdate("wallet", "pass", "name", nil)
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SendReveal", func(t *testing.T) {
|
|
_, err := svc.SendReveal("wallet", "pass", "name")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SendRedeem", func(t *testing.T) {
|
|
_, err := svc.SendRedeem("wallet", "pass", "name")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SendRenewal", func(t *testing.T) {
|
|
_, err := svc.SendRenewal("wallet", "pass", "name")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SendRevealAll", func(t *testing.T) {
|
|
_, err := svc.SendRevealAll("wallet", "pass")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SendRedeemAll", func(t *testing.T) {
|
|
_, err := svc.SendRedeemAll("wallet", "pass")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SendRegisterAll", func(t *testing.T) {
|
|
_, err := svc.SendRegisterAll("wallet", "pass")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SignMessageWithName", func(t *testing.T) {
|
|
_, err := svc.SignMessageWithName("wallet", "pass", "name", "msg")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("TransferMany", func(t *testing.T) {
|
|
_, err := svc.TransferMany("wallet", "pass", []string{"name"}, "addr")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("FinalizeAll", func(t *testing.T) {
|
|
_, err := svc.FinalizeAll("wallet", "pass")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("FinalizeMany", func(t *testing.T) {
|
|
_, err := svc.FinalizeMany("wallet", "pass", []string{"name"})
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("RenewAll", func(t *testing.T) {
|
|
_, err := svc.RenewAll("wallet", "pass")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("RenewMany", func(t *testing.T) {
|
|
_, err := svc.RenewMany("wallet", "pass", []string{"name"})
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SendTransfer", func(t *testing.T) {
|
|
_, err := svc.SendTransfer("wallet", "pass", "name", "addr")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("CancelTransfer", func(t *testing.T) {
|
|
_, err := svc.CancelTransfer("wallet", "pass", "name")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("FinalizeTransfer", func(t *testing.T) {
|
|
_, err := svc.FinalizeTransfer("wallet", "pass", "name")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("FinalizeWithPayment", func(t *testing.T) {
|
|
_, err := svc.FinalizeWithPayment("wallet", "pass", "name", "fund", "recv", 100)
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("ClaimPaidTransfer", func(t *testing.T) {
|
|
_, err := svc.ClaimPaidTransfer("wallet", "pass", "hex")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("RevokeName", func(t *testing.T) {
|
|
_, err := svc.RevokeName("wallet", "pass", "name")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("Send", func(t *testing.T) {
|
|
_, err := svc.Send("wallet", "pass", "addr", 100)
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("Lock", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Lock("wallet"))
|
|
})
|
|
t.Run("Unlock", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Unlock("wallet", "pass", 60))
|
|
})
|
|
t.Run("IsLocked", func(t *testing.T) {
|
|
_, err := svc.IsLocked("wallet")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("AddSharedKey", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.AddSharedKey("wallet", "account", "key"))
|
|
})
|
|
t.Run("RemoveSharedKey", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.RemoveSharedKey("wallet", "account", "key"))
|
|
})
|
|
t.Run("GetNonce", func(t *testing.T) {
|
|
_, err := svc.GetNonce("wallet", "name", "addr", 100)
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("ImportNonce", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.ImportNonce("wallet", "name", "addr", 100))
|
|
})
|
|
t.Run("Zap", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Zap("wallet", "account", 3600))
|
|
})
|
|
t.Run("ImportName", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.ImportName("wallet", "name", 0))
|
|
})
|
|
t.Run("RPCGetWalletInfo", func(t *testing.T) {
|
|
_, err := svc.RPCGetWalletInfo("wallet")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("LoadTransaction", func(t *testing.T) {
|
|
_, err := svc.LoadTransaction("wallet", "hex")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("ListWallets", func(t *testing.T) {
|
|
_, err := svc.ListWallets()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetStats", func(t *testing.T) {
|
|
_, err := svc.GetStats("wallet")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("IsReady", func(t *testing.T) {
|
|
_, err := svc.IsReady()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("CreateClaim", func(t *testing.T) {
|
|
_, err := svc.CreateClaim("wallet", "pass", "name")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SendClaim", func(t *testing.T) {
|
|
_, err := svc.SendClaim("wallet", "pass", "name")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
}
|
|
|
|
func TestSettingService(t *testing.T) {
|
|
svc := NewSettingService()
|
|
assert.NotNil(t, svc)
|
|
|
|
t.Run("GetExplorer", func(t *testing.T) {
|
|
_, err := svc.GetExplorer()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SetExplorer", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.SetExplorer("url"))
|
|
})
|
|
t.Run("GetLocale", func(t *testing.T) {
|
|
_, err := svc.GetLocale()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SetLocale", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.SetLocale("en"))
|
|
})
|
|
t.Run("GetCustomLocale", func(t *testing.T) {
|
|
_, err := svc.GetCustomLocale()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SetCustomLocale", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.SetCustomLocale(nil))
|
|
})
|
|
t.Run("GetLatestRelease", func(t *testing.T) {
|
|
_, err := svc.GetLatestRelease()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
}
|
|
|
|
func TestLedgerService(t *testing.T) {
|
|
svc := NewLedgerService()
|
|
assert.NotNil(t, svc)
|
|
|
|
t.Run("GetAppVersion", func(t *testing.T) {
|
|
_, err := svc.GetAppVersion()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetXPub", func(t *testing.T) {
|
|
_, err := svc.GetXPub("m/44'/5353'/0'")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
}
|
|
|
|
func TestDBService(t *testing.T) {
|
|
svc := NewDBService()
|
|
assert.NotNil(t, svc)
|
|
|
|
t.Run("Open", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Open("test"))
|
|
})
|
|
t.Run("Close", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Close())
|
|
})
|
|
t.Run("Get", func(t *testing.T) {
|
|
_, err := svc.Get("key")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("Put", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Put("key", "value"))
|
|
})
|
|
t.Run("Del", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Del("key"))
|
|
})
|
|
t.Run("GetUserDir", func(t *testing.T) {
|
|
_, err := svc.GetUserDir()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
}
|
|
|
|
func TestAnalyticsService(t *testing.T) {
|
|
svc := NewAnalyticsService()
|
|
assert.NotNil(t, svc)
|
|
|
|
t.Run("GetOptIn", func(t *testing.T) {
|
|
_, err := svc.GetOptIn()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SetOptIn", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.SetOptIn(true))
|
|
})
|
|
t.Run("Track", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Track("event", nil))
|
|
})
|
|
}
|
|
|
|
func TestConnectionsService(t *testing.T) {
|
|
svc := NewConnectionsService()
|
|
assert.NotNil(t, svc)
|
|
|
|
t.Run("connection types are defined", func(t *testing.T) {
|
|
assert.Equal(t, ConnectionType("local"), ConnectionLocal)
|
|
assert.Equal(t, ConnectionType("p2p"), ConnectionP2P)
|
|
assert.Equal(t, ConnectionType("custom"), ConnectionCustom)
|
|
})
|
|
|
|
t.Run("GetConnection", func(t *testing.T) {
|
|
_, err := svc.GetConnection()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("SetConnection", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.SetConnection(nil))
|
|
})
|
|
t.Run("SetConnectionType", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.SetConnectionType(ConnectionLocal))
|
|
})
|
|
t.Run("GetCustomRPC", func(t *testing.T) {
|
|
_, err := svc.GetCustomRPC()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
}
|
|
|
|
func TestShakedexService(t *testing.T) {
|
|
svc := NewShakedexService()
|
|
assert.NotNil(t, svc)
|
|
|
|
t.Run("GetListings", func(t *testing.T) {
|
|
_, err := svc.GetListings()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("FulfillSwap", func(t *testing.T) {
|
|
_, err := svc.FulfillSwap("offer", "addr")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetFulfillments", func(t *testing.T) {
|
|
_, err := svc.GetFulfillments()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("FinalizeSwap", func(t *testing.T) {
|
|
_, err := svc.FinalizeSwap("id")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("TransferLock", func(t *testing.T) {
|
|
_, err := svc.TransferLock("name", "pass")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("TransferCancel", func(t *testing.T) {
|
|
_, err := svc.TransferCancel("name", "pass")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("FinalizeLock", func(t *testing.T) {
|
|
_, err := svc.FinalizeLock("name", "pass")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("FinalizeCancel", func(t *testing.T) {
|
|
_, err := svc.FinalizeCancel("name", "pass")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("LaunchAuction", func(t *testing.T) {
|
|
_, err := svc.LaunchAuction("name", nil)
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("DownloadProofs", func(t *testing.T) {
|
|
_, err := svc.DownloadProofs("id")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("RestoreOneListing", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.RestoreOneListing("id"))
|
|
})
|
|
t.Run("RestoreOneFill", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.RestoreOneFill("id"))
|
|
})
|
|
t.Run("GetExchangeAuctions", func(t *testing.T) {
|
|
_, err := svc.GetExchangeAuctions()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("ListAuction", func(t *testing.T) {
|
|
_, err := svc.ListAuction("name", 100, 200, 3600)
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetFeeInfo", func(t *testing.T) {
|
|
_, err := svc.GetFeeInfo()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
t.Run("GetBestBid", func(t *testing.T) {
|
|
_, err := svc.GetBestBid("id")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
}
|
|
|
|
func TestClaimService(t *testing.T) {
|
|
svc := NewClaimService()
|
|
assert.NotNil(t, svc)
|
|
|
|
t.Run("AirdropGenerateProofs", func(t *testing.T) {
|
|
_, err := svc.AirdropGenerateProofs("address")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
}
|
|
|
|
func TestLoggerService(t *testing.T) {
|
|
svc := NewLoggerService()
|
|
assert.NotNil(t, svc)
|
|
|
|
t.Run("Info", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Info("message"))
|
|
})
|
|
t.Run("Warn", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Warn("message"))
|
|
})
|
|
t.Run("Error", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Error("message"))
|
|
})
|
|
t.Run("Log", func(t *testing.T) {
|
|
assertNotImplemented(t, svc.Log("info", "message"))
|
|
})
|
|
t.Run("Download", func(t *testing.T) {
|
|
_, err := svc.Download()
|
|
assertNotImplemented(t, err)
|
|
})
|
|
}
|
|
|
|
func TestHip2Service(t *testing.T) {
|
|
svc := NewHip2Service()
|
|
assert.NotNil(t, svc)
|
|
|
|
t.Run("FetchAddress", func(t *testing.T) {
|
|
_, err := svc.FetchAddress("test.hns")
|
|
assertNotImplemented(t, err)
|
|
})
|
|
}
|